가장 기본적인 파일 읽기 예제부터 시작해 보겠습니다. journal1.txt라는 코드 파일과 동일한 디렉터리에 파일이 있다고 가정해 보겠습니다.journal1.txt.
打开文件的标准方式是使用内置open()函数，默认从io模块导入。
file = open("journal1.txt", 'r')
for line in file:
print(line)
file.close()open()函数接受许多参数，用于以高级方式与文件交互，但大多数情况下，你只需要前两个参数
第一个参数file接受一个字符串，该字符串包含打开的文件的绝对路径或相对路径。这是唯一严格要求的参数。
第二个参数mode接受一个指示文件模式的字符串。如果未指定，将使用'rt'，这意味着它将文件作为文本读取。模式'r'实际上是相同的，因为文本模式 ( t) 是默认行为的一部分。
我可以用这行来代替，得到同样的行为。。。
file = open("journal1.txt")但我个人更喜欢明确指出我是在阅读（r），写作（w），还是你有什么。
从<strong>open()</strong>返回的所有“文件”对象都是可迭代的。对于文本文件，返回一个TextIOWrapper对象。在上面的示例中，我遍历TextIOWrapper对象文件中的行，并打印出每一行。
处理完文件后，我需要使用file.close()关闭它。 重要的是不要依赖垃圾收集器为你关闭文件，因为这种行为既不能保证也不方便实现。此外，Python 不能保证在调用.close()之前完成对文件的写入。
运行该代码，至少在我的情况下，不会打印出journal1.txt内容：
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()可能是一件非常痛苦的事情，尤其是当你考虑到打开文件时可能出现的错误时。值得庆幸的是，还有一种更简洁的方法：上下文管理器！
上下文管理器由Python 中的with语句定义。我可以使用以下语法重写我之前的代码：
with open("journal1.txt", 'r') as file:
for line in file:
print(line)调用open()函数，如果成功，则生成的TextIOWrapper对象存储在 中file，并且可以在with语句的主体中使用。一旦控制离开with语句，file.close()就会被隐式调用；你永远不必记得调用它！
我们将在下一章更深入地介绍这一点。
该文档提到了几种可用于open()的模式：
r打开文件进行读取（默认）。
w打开或创建文件以首先写入、删除（截断）其内容。
a打开或创建要写入的文件，但追加到末尾而不是截断。
x创建并打开一个新文件进行写入；它无法打开现有文件。
+打开文件进行读写（见下表）。
t以文本模式处理文件（默认）。
b以二进制模式处理文件。
这些模式标志可以组合在一起。例如，在二进制模式下，a+b允许写入和读取，其中写入附加到文件末尾。
+标志始终与另一标志组合。当与r结合使用时，它添加了a的功能，但它从文件开头开始（不截断）。当与w、a或x组合时，它也允许读取。
使用此表可以最好地理解不同标志的行为：
| 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()，readline()或者readlines()函数以文本模式读取文件，也可以直接迭代
当然，这需要使用适当的文件模式标志打开文件进行读取（请参阅“文件模式”部分）。如果需要检查对象文件是否可以读取，请使用file.readable()
파일을 여는 표준 방법은 다음을 사용하는 것입니다. 내장 open() 함수는 기본적으로 io 모듈에서 가져옵니다.
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!open() 함수는 고급 방식으로 파일과 상호작용하기 위해 여러 매개변수를 허용하지만 대부분의 경우 첫 번째 매개변수만 필요합니다. 두 개의 매개변수 🎜
첫 번째 매개변수 file는 열린 파일의 절대 경로 또는 상대 경로가 포함된 문자열을 허용합니다. 이는 유일하게 엄격하게 필요한 매개변수입니다. 🎜
두 번째 매개변수 mode는 파일 모드를 나타내는 문자열을 허용합니다. 지정하지 않으면 'rt'가 사용됩니다. 이는 파일을 텍스트로 읽는다는 의미입니다. 텍스트 모드( t)가 기본 동작의 일부이므로 'r' 모드는 사실상 동일합니다. 🎜
대신 이 줄을 사용하면 동일한 동작을 얻을 수 있습니다. . . 🎜
with open("journal1.txt", 'r') as file:
contents = file.read(20)
print(contents)
# Could this be where하지만 저는 개인적으로 내가 읽고 있는지(r), 쓰고 있는지(w), 아니면 당신이 읽고 있는지 명확하게 표시하는 것을 선호합니다. 무엇을 가지고 있습니다. 🎜
<strong>open()</strong>에서 반환된 모든 "파일" 객체는 반복 가능합니다. 텍스트 파일의 경우 TextIOWrapper 개체를 반환합니다. 위의 예에서는 TextIOWrapper 개체 파일의 줄을 반복하고 각 줄을 인쇄합니다. 🎜
파일을 처리한 후 file.close()를 사용하여 파일을 닫아야 합니다. 파일을 닫을 때 가비지 수집기에 의존하지 않는 것이 중요합니다. 이 동작은 보장되지도 않고 구현하기도 편리하지 않기 때문입니다. 또한 Python은 .close()를 호출하기 전에 파일 쓰기가 완료된다는 것을 보장하지 않습니다. 🎜
적어도 제 경우에는 이 코드를 실행해도 journal1.txt 내용이 인쇄되지 않습니다: 🎜
with open("journal1.txt", 'r') as file:
contents = file.readline()
print(contents)
# Could this be where all missing things are found?실제로는 항상 close()를 호출하는 것을 기억하세요. 이는 매우 고통스러울 수 있습니다. 특히 파일을 열 때 발생할 수 있는 오류를 고려할 때 더욱 그렇습니다. 다행히 컨텍스트 관리자라는 더 간단한 방법이 있습니다! 🎜
컨텍스트 관리자는 Python의 with 문으로 정의됩니다. 다음 구문을 사용하여 이전 코드를 다시 작성할 수 있습니다. 🎜
with open("journal1.txt", 'r') as file:
contents = file.readline(20)
print(contents)
# Could this be whereopen() 함수를 호출하고 성공하면 결과 TextIOWrapper객체는 <code>file에 저장되며 with 문의 본문에서 사용할 수 있습니다. 제어가 with 문을 벗어나면 file.close()가 암시적으로 호출됩니다. 🎜
이 내용은 다음 장에서 더 자세히 다루겠습니다. 🎜
문서에서는 open() 모드: 🎜<ul data-id="u738a58b-0cEEKUPD" class=" list-paddingleft-2">
<li><p><code>r읽을 파일을 엽니다(기본값). 🎜
w파일을 열거나 생성하여 먼저 쓰고 내용을 삭제(잘라내기)하세요. 🎜
a쓰기 위해 파일을 열거나 생성하지만 자르지 않고 끝에 추가합니다. 🎜
x는 쓰기 위해 새 파일을 만들고 엽니다. 기존 파일을 열 수 없습니다. 🎜
+읽고 쓰기 위해 파일을 엽니다(아래 표 참조). 🎜
t텍스트 모드에서 파일을 처리합니다(기본값). 🎜
b바이너리 모드에서 파일을 처리합니다. 🎜
이러한 모드 플래그는 함께 결합될 수 있습니다. 예를 들어, 이진 모드에서 a+b는 쓰기와 읽기를 모두 허용하며 쓰기는 파일 끝에 추가됩니다. 🎜
+ 기호는 항상 다른 기호와 결합됩니다. r과 함께 사용하면 a의 기능이 추가되지만 파일의 시작 부분에서 시작됩니다(잘림 없음). w, a 또는 x와 결합하면 읽기도 가능합니다. 🎜
다음 표를 사용하면 다양한 플래그의 동작을 가장 잘 이해할 수 있습니다. 🎜
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!
#read(), readline() 또는 readlines() 함수를 사용하여 읽을 수 있습니다. 텍스트 모드 파일을 직접 반복할 수도 있습니다. 🎜
물론 이를 위해서는 적절한 파일 모드 플래그를 사용하여 읽기 위해 파일을 열어야 합니다("파일 모드" 섹션 참조). 객체 파일을 읽을 수 있는지 확인하고 싶다면 file.reader() 함수를 사용하세요. 🎜
让我们对比一下读取文件的三种方式：
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())위 내용은 Python 파일 처리 방법 예시 코드 분석의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
![[웹 프런트엔드] Node.js 빠른 시작](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
