Mari mulakan dengan contoh bacaan fail yang paling asas. Katakan saya mempunyai fail dalam direktori yang sama dengan fail kod saya bernama journal1.txt Cara standard untuk membuka fail dengan
ialah menggunakan fungsi open() terbina dalam, yang diimport daripada io modul secara lalai. Fungsi
file = open("journal1.txt", 'r')
for line in file:
print(line)
file.close()open() menerima beberapa parameter untuk berinteraksi dengan fail dengan cara lanjutan, tetapi dalam kebanyakan kes anda hanya memerlukan dua parameter pertama
Parameter pertama file Menerima rentetan yang mengandungi laluan mutlak atau relatif ke fail yang terbuka. Ini adalah satu-satunya parameter yang sangat diperlukan.
Parameter kedua mode menerima rentetan yang menunjukkan mod fail . Jika tidak dinyatakan, 'rt' akan digunakan, bermakna ia membaca fail sebagai teks. Mod 'r' sebenarnya sama, kerana mod teks ( t) ialah sebahagian daripada gelagat lalai.
Saya boleh menggunakan baris ini dan mendapat gelagat yang sama. . .
file = open("journal1.txt") Tetapi saya secara peribadi lebih suka menjelaskan sama ada saya membaca (r), menulis (w), atau apa yang anda miliki.
Semua objek "fail" yang dikembalikan daripada <code><strong>open()</strong>open() boleh diubah. TextIOWrapperUntuk fail teks, mengembalikan objek TextIOWrapper. Dalam contoh di atas, saya menggelungkan melalui baris dalam fail objek
file.close()Selepas memproses fail, saya perlu menutupnya menggunakan . Adalah penting untuk tidak .close() bergantung pada pemungut sampah untuk menutup fail untuk anda, kerana tingkah laku ini tidak dijamin dan tidak mudah untuk dilaksanakan. Selain itu, Python tidak menjamin bahawa penulisan pada fail akan selesai sebelum memanggil
journal1.txt Menjalankan kod ini, sekurang-kurangnya dalam kes saya, tidak mencetak
Could this be where all missing things are found? Magic Hair Only for the Pure of Heart Not naturally occurring? Could result in minor gravity anomalies!
close() Dalam amalan, sentiasa ingat untuk memanggil Boleh menjadi kesakitan yang nyata, terutamanya apabila anda mempertimbangkan ralat yang boleh berlaku semasa membuka fail. Syukurlah, ada cara yang lebih mudah: Pengurus Konteks
Pengurus konteks with ditakrifkan oleh pernyataan
with open("journal1.txt", 'r') as file:
for line in file:
print(line)open() memanggil fungsi TextIOWrapper, dan jika berjaya, objek file yang terhasil disimpan dalam with dan boleh digunakan dalam with pernyataan yang digunakan dalam isi utama. file.close() dipanggil secara tersirat apabila kawalan meninggalkan pernyataan anda tidak perlu ingat untuk memanggilnya! Kami akan membincangkan perkara ini dengan lebih mendalam dalam bab seterusnya. Mod Failopen()Dokumentasi menyebut beberapa mod yang tersedia untuk
r
w
a
x
+
t
b
r+ sentiasa digabungkan dengan bendera lain. Apabila digunakan bersama dengan a, ia menambahkan fungsi w, tetapi ia bermula pada permulaan fail (tanpa pemotongan). Apabila digabungkan dengan a, x atau
| r r+ w w+ a a+ x x+ ---------------------|---------------------------------- allow read | ✓ ✓ ✓ ✓ ✓ allow write | ✓ ✓ ✓ ✓ ✓ ✓ ✓ create new file | ✓ ✓ ✓ ✓ ✓ ✓ open existing file | ✓ ✓ ✓ ✓ ✓ ✓ erase file contents | ✓ ✓ allow seek | ✓ ✓ ✓ ✓ ✓ position at start | ✓ ✓ ✓ ✓ ✓ ✓ position at end | ✓ ✓
read() Kita boleh menggunakan fungsi readline(), readlines() atau
file.readable() Sudah tentu, ini memerlukan membuka fail untuk membaca dengan bendera mod fail yang sesuai (lihat bahagian "Mod Fail"). Jika anda perlu menyemak sama ada fail objek boleh dibaca, gunakan fungsi
让我们对比一下读取文件的三种方式：
read()函数将文件的全部内容作为一个长字符串读取。
with open("journal1.txt", 'r') as file:
contents = file.read()
print(contents)
# Could this be where all missing things are found?
# Magic Hair Only for the Pure of Heart
# Not naturally occurring?
# Could result in minor gravity anomalies!或者，你可以告诉read()从文件流中读取的最大字符数：
with open("journal1.txt", 'r') as file:
contents = file.read(20)
print(contents)
# Could this be wherereadline()函数的行为与read()完全相同，只是它在遇到换行符时停止读取。换行符包含在返回的字符串中。
with open("journal1.txt", 'r') as file:
contents = file.readline()
print(contents)
# Could this be where all missing things are found?与read()一样，你可以指定要读取的最大字符数：
with open("journal1.txt", 'r') as file:
contents = file.readline(20)
print(contents)
# Could this be wherereadlines()函数以字符串列表的形式返回整个文件，每个字符串为一行。
with open("journal1.txt", 'r') as file:
contents = file.readlines()
for c in contents:
print(c)
# Could this be where all missing things are found?
#
# Magic Hair Only for the Pure of Heart
#
# Not naturally occurring?
#
# Could result in minor gravity anomalies!
#你会注意到每一行都包含换行符。我们可以通过在每个字符串上调用.strip()函数来删除它。
with open("journal1.txt", 'r') as file:
contents = file.readlines()
for c in contents:
print(c.strip())
# Could this be where all missing things are found?
# Magic Hair Only for the Pure of Heart
# Not naturally occurring?
# Could result in minor gravity anomalies!你还可以通过指定最大字符数来限制从文件中读取的内容。然而，与以前不同的是，这不是硬性限制。相反，一旦到目前为止从所有行读取的字符总数超过了指定的限制，则只会读取当前行的其余部分。
通过比较read()和readlines()可以最好地理解这一点。首先，我将阅读限制为60个字符：
with open("journal1.txt", 'r') as file:
contents = file.read(60)
print(contents)
# Could this be where all missing things are found?
# Magic Hair将readlines()与使用 60 个字符的“提示”进行比较：
with open("journal1.txt", 'r') as file:
contents = file.readlines(60)
for c in contents:
print(c.strip())
# Could this be where all missing things are found?
# Magic Hair Only for the Pure of Heart在第二个示例中，读取前两行的全部内容，但不再读取。
与其他两个函数不同，readlines()总是读取整行。
如你之前所见，我们可以直接迭代文件：
with open("journal1.txt", 'r') as file:
for line in file:
print(line)
# Could this be where all missing things are found?
# Magic Hair Only for the Pure of Heart
# Not naturally occurring?
# Could result in minor gravity anomalies!这在功能上与以下内容相同：
with open("journal1.txt", 'r') as file:
for line in file.readlines():
print(line)两者的区别在于第一种方法，直接迭代，是惰性的，而第二种方法在迭代内容之前首先读取整个文件。
使用write()orwritelines()函数，我们可以以几乎相同的方式写入文件。
这需要打开文件进行写入（参见“文件模式”部分）。file.writable()函数可用于检查file对象是否可写。
在本节的示例中，我将在底部的注释中显示文件内容。
write()函数将给定的行写入文件。
我可以使用write()将整个多行字符串写入一个名为journal3.txt的新文件，如下所示：
entry = """If you go on enough road trips
chances are, you've seen a
certain bumper sticker:
WHAT IS THE MYSTERY SHACK?
"""
with open("journal3.txt", 'x') as file:
file.write(entry)
# If you go on enough road trips
# chances are, you've seen a
# certain bumper sticker:
# WHAT IS THE MYSTERY SHACK?
#只要journal3.txt不存在，它将使用给定的内容创建。
我可以使用w文件模式覆盖journal3.txt的全部内容：
with open("journal3.txt", 'w') as file:
file.write("GNOMES\nWEAKNESS?\n")
# GNOMES
# WEAKNESS?
#注意：注意你的文件模式！
w并将w+删除文件的全部内容。使用a或a+写入文件末尾。
我可以使用a文件模式附加到文件中：
with open("journal3.txt", 'a') as file:
file.write("leaf blowers\n")
# GNOMES
# WEAKNESS?
# leaf blowers
#write()函数返回一个整数，表示写入的字符数。
writelines()函数将字符串列表写入文件。
lines = [
"Finally back safe and sound\n",
"from one of the weirdest days\n",
"at Gravity Falls.\n"
]
with open("journal3.txt", 'w') as file:
file.writelines(lines)
# Finally back safe and sound
# from one of the weirdest days
# at Gravity Falls.
#与 withwrite() 不同，writelines()函数只返回None。
file.seek()函数允许你在文件对象file中逐个字符地来回移动。处理文本流时，它接受一个参数：一个正整数，表示要移动到的新位置，表示为从开头开始的字符数。
除了改变位置之外，该file.seek()函数还将返回一个表示文件中新绝对位置的整数。你可用file.tell()来获取该文件的当前位置。
r+文件模式最好与函数seek()一起使用，尽管它可以与除 a和a+之外的任何其他文件模式一起使用。
我将首先使用seek()函数来读取journal1.txt文件的一部分：
with open("journal1.txt", 'r') as file:
file.seek(50)
contents = file.read(5)
print(contents)
# MAGIC我将编写journal3.txt文件的新初始版本：
with open("journal3.txt", 'w') as file:
file.write("FLOATING EYEBALLS")
# FLOATING EYEBALLS我可以使用该r+模式更改此文件的一部分。
注意：
write()命令将始终覆盖文件的现有内容，除非你追加到末尾。要将文本非破坏性地插入文件，通常最好将整个内容作为字符串（或列表）读取，编辑字符串，然后将其写回。
在这里，我将用“NONSENSE！”替换“EYEBALLS”这个词：
with open("journal3.txt", 'r+') as file:
file.seek(9)
file.write("NONSENSE!")
# FLOATING NONSENSE!打开文件后，我从头移动到第 9 个字符，然后write()是新数据。
当你以二进制模式 ( b) 打开文件时，你可以以更动态的方式在文件中移动，使用两个参数而不是一个参数：
offset：字符移动的距离（可以是负数）
whence: 计算偏移量的位置：0表示文件的开始位置（默认），1表示当前位置，2表示文件的结束位置。
不幸的是，使用whence参数不适用于以文本模式打开的文件。
与处理文件相关的四个最常见错误如下：
r和r+模式要求文件在打开之前存在。否则，将引发FileNotFoundError错误：
try:
with open("notreal.txt", 'r') as file:
print(file.read())
except FileNotFoundError as e:
print(e)x和x+文件模式专门用于创建新文件。如果文件已存在，将引发FileExistsError错误：
try:
with open("journal3.txt", 'x+') as file:
print(file.read())
except FileExistsError as e:
print(e)每当你尝试读取仅打开用于写入的文件或写入仅打开用于读取的文件时都会引发错误io.UnsupportedOperation：
import io
try:
with open("journal3.txt", 'w') as file:
print(file.read())
except io.UnsupportedOperation as e:
print(e)
try:
with open("journal3.txt", 'r') as file:
file.write('')
except io.UnsupportedOperation as e:
print(e)一些聪明的读者会记得，虽然UNIX使用\n作为行分隔符，但Windows使用\r\n。当我们读写文件时，这肯定很重要，对吧？
事实上，Python 在幕后为我们抽象了这一点。无论操作系统如何，在以文本模式写入文件时始终用作行分隔符！<strong>\n</strong>
到目前为止，我只使用了与代码相同文件夹中的文件，但这很少是我们想要的！我们需要能够构建文件路径。
问题是，所有系统上的文件路径都不相同。UNIX风格的系统，如macOS和Linux，使用UNIX文件路径约定，而Windows使用完全不同的方案。我们的解决方案必须对两者都有效，这意味着硬路径不是一个选项。
为了解决这个问题，Python 提供了两个模块：os和pathlib。
Python实际上提供了多个用于构建路径的类，这取决于你的特定需求。但是，在大多数情况下，你应该只使用pathlib.Path。
假设我想在当前用户的主文件夹中创建一个名为.dead_simple_python的特殊目录，然后将文件写入该位置。我会这样做：
首先，我创建一个Path()对象，指向最终所需的目录（而不是文件）。
在Path()构造函数中，我将路径的每个部分作为单独的字符串传递。我可以使用类方法Path.home()来获取用户目录的路径。
from pathlib import Path import os file_path = Path(Path.home(), ".dead_simple_python")
接下来，我将使用file_path.exists()检查路径是否已经存在。如果它不存在，我将使用os.makedirs函数用于创建路径中缺少的任何目录：
if not file_path.exists(): os.makedirs(file_path)
最后，我可以将文件名添加到已经拥有的路径对象中，然后打开该文件进行写入：
file_path = file_path.joinpath("journal4.txt")
with file_path.open('w') as file:
lines = [
"If you've ever taken a road trip \n",
"through the Pacific Northwest, you've \n",
"probably seen a bumper sticker for a \n",
"place called Gravity Falls.\n"
]
file.writelines(lines)你会注意到我使用了file_path.open('w')，而不是open(file_path, 'w')。从技术上讲，两者的作用完全相同，尽管成员函数是首选。
open("journal1.txt")之所以有效，是因为它是一个相对路径，从执行代码的目录开始。
如果我的代码所在的目录中有一个journals/目录，我可以使用它：
from pathlib import Path
file_path = Path("journals", "journal1.txt")
with file_path.open('r') as file:
print(file.read())只要我不是从绝对路径开始，比如由Path.home()生成的路径，路径都是相对的。
但是如果我想向上移动一个目录而不是向下移动呢？你可能会尝试使用..，但正如你可能猜到的，这并不能保证在所有操作系统上都是可移动的。相反，我可以使用os.pardir移动到上一个目录。
想象一下，我们有一个如下所示的目录结构：
example ├── code │ └── read_file.py └── journals └── journal1.txt
如果在path_relative2/code运行python read_file.py，我可以通过以下方式访问journal1.txt：
from pathlib import Path
import os
file_path = Path(os.pardir, "journals", "journal1.txt")
with file_path.open('r') as file:
print(file.read())Atas ialah kandungan terperinci Kaedah pemprosesan fail Python contoh analisis kod. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
