Obtenez toutes les connaissances sur la lecture de fichiers en Python dans un seul article

Les fichiers sont partout, quel que soit le langage de programmation que nous utilisons, le traitement des fichiers est essentiel pour chaque programmeur

Le traitement des fichiers est une méthode utilisée pour créer des fichiers, écrire des données et les lire. Dans le processus de récupération des données, Python a une multitude de packages pour traiter différents types de fichiers, ce qui nous permet d'effectuer le traitement des fichiers plus facilement et plus commodément

Aperçu de cet article :

• Utilisez le gestionnaire de contexte pour ouvrir des fichiers
• En mode de lecture de fichier Python
• Lire un fichier texte
• Lire le fichier CSV
• Lire le fichier JSON

Ouvrir le fichier

Avant d'accéder au contenu du fichier, nous devons ouvrir le fichier. Python fournit une fonction intégrée qui nous aide à ouvrir des fichiers dans différents modes. La fonction open() accepte deux paramètres de base : le nom du fichier et le mode

Le mode par défaut est "r", qui ouvre le fichier en mode lecture seule. Ces modes définissent comment nous accédons à un fichier et comment nous manipulons son contenu. La fonction open() propose plusieurs modes différents, dont nous parlerons un par un plus tard. Utilisons le fichier 'Zen of Python' pour discuter et apprendre plus tard

f = open('zen_of_python.txt', 'r')
print(f.read())
f.close()

Sortie :

The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
...

Dans le code ci-dessus, open () La fonction ouvre un fichier texte en mode lecture seule, ce qui nous permet d'obtenir des informations sur le fichier sans le modifier. Dans la première ligne, la sortie de la fonction open() est affectée à un objet f qui représente le fichier texte. Dans la deuxième ligne, nous utilisons la méthode read() pour lire l'intégralité du fichier et imprimer son contenu. ) se trouve dans la dernière ligne. Il est important de noter que nous devons toujours fermer les fichiers ouverts après les avoir traités pour libérer nos ressources informatiques et éviter de lancer des exceptions.

En Python, nous pouvons utiliser le gestionnaire de contexte with pour garantir que le programme libère les ressources utilisées après le fichier. fermé, cela est vrai même si une exception se produit

with open('zen_of_python.txt') as f:
 print(f.read())

Sortie :

The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
...

Le code ci-dessus crée un contexte à l'aide de l'instruction with et le lie à la variable f via laquelle toutes les méthodes d'objet fichier peuvent accéder à l'objet fichier. La méthode read() lit l'intégralité du fichier sur la deuxième ligne, puis utilise la fonction print() pour afficher le contenu du fichier

Lorsque le programme atteint la fin du contexte du bloc d'instruction with, il ferme le fichier pour libérer des ressources et s'assurer que d'autres programmes peuvent les appeler normalement. Habituellement, lorsque nous traitons d'objets qui n'ont plus besoin d'être utilisés et doivent être fermés immédiatement (tels que des fichiers, des bases de données et des connexions réseau), il est fortement recommandé d'utiliser l'instruction with

Ce qu'il faut noter ici, c'est que même après avoir quitté le bloc with context manager, nous La variable f est également accessible, mais le fichier est fermé. Essayons quelques propriétés d'objet fichier et voyons si les variables sont toujours là et accessibles :

print("Filename is '{}'.".format(f.name))
if f.closed:
 print("File is closed.")
else:
 print("File isn't closed.")

Sortie :

Filename is 'zen_of_python.txt'.
File is closed.

Mais à ce stade, il n'est pas possible de lire ou d'écrire dans le fichier, aucun accès lors de la fermeture du fichier. Toute tentative avec son contenu entraîne l'erreur suivante :

f.read()

Output:

---------------------------------------------------------------------------
ValueErrorTraceback (most recent call last)
~AppDataLocalTemp/ipykernel_9828/3059900045.py in <module>
----> 1 f.read()
ValueError: I/O operation on closed file.

File Reading Mode in Python

Comme nous l'avons mentionné précédemment, nous devons spécifier le mode lors de l'ouverture d'un fichier. Le tableau suivant présente les différents modes de fichier en Python :

Description du mode

'r' ouvre un fichier en lecture seule

• 'w' ouvre un fichier en écriture. Si le fichier existe, il sera écrasé, sinon un nouveau fichier sera créé
• 'a' ouvre un fichier pour l'ajouter uniquement. Si le fichier n'existe pas, il sera créé
• 'x' crée un nouveau fichier. Échec si le fichier existe
• '+' Ouvrir un fichier pour mise à jour
On peut également spécifier d'ouvrir le fichier en mode texte "t", en mode par défaut ou en mode binaire "b". Voyons comment copier le fichier image dataquest_logo.png en utilisant une simple instruction :

with open('dataquest_logo.png', 'rb') as rf:
 with open('data_quest_logo_copy.png', 'wb') as wf:
 for b in rf:
 wf.write(b)

Le code ci-dessus copie l'image du logo Dataquest et la stocke dans le même chemin. Le mode 'rb' ouvre le fichier en mode binaire pour la lecture, tandis que le mode 'wb' ouvre le fichier en mode texte pour l'écriture parallèle

Lecture de fichiers texte

Il existe plusieurs façons de lire des fichiers texte en Python, ci-dessous nous en présentons quelques-unes utiles méthodes pour lire le contenu des fichiers texte

Jusqu'à présent, nous avons appris que l'intégralité du contenu d'un fichier peut être lu à l'aide de la méthode read(). Que se passe-t-il si nous voulons seulement lire quelques octets du fichier texte, nous pouvons spécifier le nombre d'octets dans la méthode read(). Essayons :

with open('zen_of_python.txt') as f:
 print(f.read(17))

Sortie :

The Zen of Python

Le code simple ci-dessus lit les 17 premiers octets du fichier zen_of_python.txt et les imprime

Parfois, il est plus logique de lire le contenu d'un fichier texte sur une seule ligne. une fois, dans ce cas, nous pouvons utiliser la méthode readline()

with open('zen_of_python.txt') as f:
 print(f.readline())

Output:

The Zen of Python, by Tim Peters

Le code ci-dessus renvoie la première ligne du fichier, et si nous appelons à nouveau la méthode, elle renverra la deuxième ligne dans le fichier, etc., comme suit :

with open('zen_of_python.txt') as f:
 print(f.readline())
 print(f.readline())
 print(f.readline())
 print(f.readline())

Sortie :

The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.

Cette méthode utile peut nous aider à lire l'intégralité du fichier de manière incrémentielle.

以下代码通过逐行迭代来输出整个文件，直到跟踪我们正在读取或写入文件的位置的文件指针到达文件末尾。当 readline() 方法到达文件末尾时，它返回一个空字符串

with open('zen_of_python.txt') as f:
 line = f.readline()
 while line:
 print(line, end='')
 line = f.readline()

Output:

The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

上面的代码在 while 循环之外读取文件的第一行并将其分配给 line 变量。在 while 循环中，它打印存储在 line 变量中的字符串，然后读取文件的下一行。while 循环迭代该过程，直到 readline() 方法返回一个空字符串。空字符串在 while 循环中的计算结果为 False，因此迭代过程终止

读取文本文件的另一个有用方法是 readlines() 方法，将此方法应用于文件对象会返回包含文件每一行的字符串列表

with open('zen_of_python.txt') as f:
 lines = f.readlines()

让我们检查 lines 变量的数据类型，然后打印它：

print(type(lines))
print(lines)

Output:

<class 'list'>
['The Zen of Python, by Tim Petersn', 'n', 'Beaut...]

它是一个字符串列表，其中列表中的每个项目都是文本文件的一行，``n` 转义字符表示文件中的新行。此外，我们可以通过索引或切片操作访问列表中的每个项目：

print(lines)
print(lines[3:5])
print(lines[-1])

Output:

['The Zen of Python, by Tim Petersn', 'n', 'Beautiful is better than ugly.n', ... -- let's do more of those!"]
['Explicit is better than implicit.n', 'Simple is better than complex.n']
Namespaces are one honking great idea -- let's do more of those!

读取 CSV 文件

到目前为止，我们已经学会了如何使用常规文本文件。但是有时数据采用 CSV 格式，数据专业人员通常会检索所需信息并操作 CSV 文件的内容

接下来我们将使用 CSV 模块，CSV 模块提供了有用的方法来读取存储在 CSV 文件中的逗号分隔值。我们现在就尝试一下

import csv
with open('chocolate.csv') as f:
 reader = csv.reader(f, delimiter=',')
 for row in reader:
 print(row)

Output:

['Company', 'Bean Origin or Bar Name', 'REF', 'Review Date', 'Cocoa Percent', 'Company Location', 'Rating', 'Bean Type', 'Country of Origin']
['A. Morin', 'Agua Grande', '1876', '2016', '63%', 'France', '3.75', 'Âxa0', 'Sao Tome']
['A. Morin', 'Kpime', '1676', '2015', '70%', 'France', '2.75', 'Âxa0', 'Togo']
['A. Morin', 'Atsane', '1676', '2015', '70%', 'France', '3', 'Âxa0', 'Togo']
['A. Morin', 'Akata', '1680', '2015', '70%', 'France', '3.5', 'Âxa0', 'Togo']
...

CSV 文件的每一行形成一个列表，其中每个项目都可以轻松的被访问，如下所示：

import csv
with open('chocolate.csv') as f:
 reader = csv.reader(f, delimiter=',')
 for row in reader:
 print("The {} company is located in {}.".format(row[0], row[5]))

Output:

The Company company is located in Company Location.
The A. Morin company is located in France.
The A. Morin company is located in France.
The A. Morin company is located in France.
The A. Morin company is located in France.
The Acalli company is located in U.S.A..
The Acalli company is located in U.S.A..
The Adi company is located in Fiji.
...

很多时候，使用列的名称而不是使用它们的索引，这通常对专业人员来说更方便。在这种情况下，我们不使用 reader() 方法，而是使用返回字典对象集合的 DictReader() 方法

import csv
with open('chocolate.csv') as f:
 dict_reader = csv.DictReader(f, delimiter=',')
 for row in dict_reader:
 print("The {} company is located in {}.".format(row['Company'], row['Company Location']))

Output:

The A. Morin company is located in France.
The A. Morin company is located in France.
The A. Morin company is located in France.
The A. Morin company is located in France.
The Acalli company is located in U.S.A..
The Acalli company is located in U.S.A..
The Adi company is located in Fiji.
...

读取 JSON 文件

我们主要用于存储和交换数据的另一种流行文件格式是 JSON，JSON 代表 JavaScript Object Notation，允许我们使用逗号分隔的键值对存储数据

接下来我们将加载一个 JSON 文件并将其作为 JSON 对象使用，而不是作为文本文件，为此我们需要导入 JSON 模块。然后在 with 上下文管理器中，我们使用了属于 json 对象的 load() 方法，它加载文件的内容并将其作为字典存储在上下文变量中。

import json
with open('movie.json') as f:
 content = json.load(f)
 print(content)

Output:

{'Title': 'Bicentennial Man', 'Release Date': 'Dec 17 1999', 'MPAA Rating': 'PG', 'Running Time min': 132, 'Distributor': 'Walt Disney Pictures', 'Source': 'Based on Book/Short Story', 'Major Genre': 'Drama', 'Creative Type': 'Science Fiction', 'Director': 'Chris Columbus', 'Rotten Tomatoes Rating': 38, 'IMDB Rating': 6.4, 'IMDB Votes': 28827}

让我们检查内容变量的数据类型：

print(type(content))

Output:

<class 'dict'>

它的数据类型是字典，因此我们可以方便的从中提取数据

print('{} directed by {}'.format(content['Title'], content['Director']))

Output:

Bicentennial Man directed by Chris Columbus

总结

今天我们讨论了 Python 中的文件处理，重点是读取文件的内容。我们了解了 open() 内置函数、with 上下文管理器，以及如何读取文本、CSV 和 JSON 等常见文件类型。

好了，这就是今天分享的全部内容，喜欢就点个赞吧~

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!