用Python讀寫文件(指南)

本文為譯文, 原文鏈接:

Reading and Writing Files in Python (Guide)

by James Mertz

[TOC]

使用Python最常見的任務之一是讀取和寫入文件。無論是寫入簡單的文本文件，讀取復雜的服務器日志，甚至是分析原始字節數據，所有這些情況都需要讀取或寫入文件。

在本教程中，您將學習：

• 什么組成了一個文件，為什么它在python中很重要
• 用Python讀寫文件的基礎知識
• 讀寫文件的一些基本場景

本教程主要針對初學者到中級的 Pythonistas，但這里有一些提示，更高級的程序員可能也會從中受益。

什么是文件?

在討論如何使用Python中的文件之前，了解文件的具體內容以及現代操作系統如何處理它們是很重要的。

從本質上講，文件是用于存儲數據的連續字節集。這些數據以特定格式組織，可以是任何像文本文件一樣簡單的數據，也可以像程序可執行文件一樣復雜。最后，這些字節文件被翻譯成二進制文件1，0以便計算機更容易處理。

大多數現代文件系統上的文件由三個主要部分組成：

1. 標題(Header)：有關文件內容的元數據（文件名，大小，類型等）
2. 數據(Data)：由創建者或編輯者編寫的文件內容
3. 文件結束符（EOF）：表示文件結尾的特殊字符

FileFormat.02335d06829d.png

數據表示的內容取決于所使用的格式規范，通常由擴展名表示。例如，具有.gif擴展名的文件最可能符合GIF規范。有數百個（甚至上千個）文件擴展名。對于本教程，您將只處理.txt或.csv文件擴展名。

文件路徑

在操作系統上訪問文件時，需要文件路徑。文件路徑是表示文件位置的字符串。它分為三個主要部分：

1. 文件夾路徑：文件系統上的文件夾位置，后續文件夾由正斜杠/（Unix）或反斜杠\（Windows）分隔
2. 文件名：文件的實際名稱
3. 擴展名：文件路徑的末尾(句號（.）后的內容)，用于表示文件類型

這是一個簡單的例子。假設您有一個位于文件結構中的文件，如下所示：

/
│
├── path/
|   │
│   ├── to/
│   │   └── cats.gif
│   │
│   └── dog_breeds.txt
|
└── animals.csv

假設您要訪問cats.gif文件，并且您當前的位置位于文件夾path中。要訪問該文件，您需要瀏覽該path文件夾，然后查看to文件夾，最后到達cats.gif文件。文件夾路徑是path/to/。文件名是cats。文件擴展名是.gif。所以完整的道路是path/to/cats.gif。

現在假設您當前的位置或當前工作目錄（cwd）位于我們的示例文件夾結構的to文件夾中。可以通過文件名和擴展名cats.gif簡單地引用文件，而不用引用完整路徑path/to/cats.gif。

/
│
├── path/
|   │
|   ├── to/  ← 你的當前工作目錄 (cwd)在這兒
|   │   └── cats.gif  ← 訪問這個文件
|   │
|   └── dog_breeds.txt
|
└── animals.csv

但如果要訪問dog_breeds.txt呢？如果不使用完整路徑，您將如何訪問？您可以使用特殊字符double-dot（..）來移動到上一個目錄。這意味著../dog_breeds.txt會從文件夾to引用到dog_breeds.txt：

/
│
├── path/  ← 引用該父目錄
|   │
|   ├── to/  ← 當前工作目錄 (cwd)
|   │   └── cats.gif
|   │
|   └── dog_breeds.txt  ← 訪問該文件
|
└── animals.csv

double-dot（..）可以鏈接在一起以遍歷當前目錄上的多個目錄。例如，要從to文件夾訪問animals.csv，您將使用../../animals.csv。

Line Endings

處理文件數據時經常遇到的一個問題是新行或行結尾的表示。行結尾起源于莫爾斯電碼時代，那時一個特定的符號被用來傳達傳輸的結束或一條線的末端。

后來，國際標準化組織（ISO）和美國標準協會（ASA）對電傳打字機進行了標準化。ASA標準規定行尾應使用回車（序列CR或\r）和換行（LF或\n）字符（CR+LF或\r\n）。然而，ISO標準允許CR+LF字符或僅LF字符.

Windows使用CR+LF字符表示新行，而Unix和較新的Mac版本僅使用LF字符。當您在不同于文件源的操作系統上處理文件時，這可能會導致一些復雜情況。以下是一個簡單的例子。假設我們檢查在Windows系統上創建的文件dog_breeds.txt:

哈巴狗\r\n
杰克羅素梗犬\r\n
英國史賓格犬\r\n
德國牧羊犬\r\n
斯塔福郡斗牛梗\r\n
騎士國王查爾斯獵犬\r\n
金毛獵犬\r\n
西部高地白梗\r\n
拳擊手\r\n
邊境獵犬\r\n

同樣的輸出將在Unix設備上以不同方式解釋：

哈巴狗\r
\n
杰克羅素梗犬\r
\n
英國史賓格犬\r
\n
德國牧羊犬\r
\n
斯塔福郡斗牛梗\r
\n
騎士國王查爾斯獵犬\r
\n
金毛獵犬\r
\n
西部高地白梗\r
\n
拳擊手\r
\n
邊境獵犬\r
\n

這會使每一行的迭代都有問題，您可能需要考慮這樣的情況。

字符編碼

您可能面臨的另一個常見問題是字節數據的編碼。編碼是從字節數據到人類可讀字符的轉換。這通常通過指定表示字符的數值來完成。兩種最常見的編碼是ASCII和UNICODE格式。ASCII只能存儲128個字符，而Unicode最多可包含1,114,112個字符。

ASCII實際上是Unicode（UTF-8）的子集，這意味著ASCII和Unicode共享相同的數字到字符值。重要是要注意，使用不正確的字符編碼解析文件可能會導致字符失敗或誤傳。例如，如果文件是使用UTF-8編碼創建的，并且您嘗試使用ASCII編碼對其進行解析，則如果存在超出128個值的字符，則會引發錯誤。

在Python中打開和關閉文件

當您想使用文件時，首先要做的就是打開它。這是通過調用open()內置函數完成的。open()有一個必需的參數，就是文件的路徑。open()有一個返回，就是文件對象：

file = open('dog_breeds.txt')

打開文件后，接下來要學習的是如何關閉它。

:exclamation: 警告:

您應始終確保正確關閉打開的文件。

重要的是要記住，關閉文件是您的責任。在大多數情況下，在應用程序或腳本終止時，文件最終將被關閉。然而，并不能保證任何時候都會發生這種情況。這可能導致不必要的行為，包括資源泄漏。確保您的代碼以明確定義的方式運行并減少任何不需要的行為, 這也是Python（Pythonic）中的最佳實踐。

當您操作文件時，有兩種方法可以確保文件正確關閉，即使遇到錯誤也是如此。關閉文件的第一種方法是使用try-finally塊：

reader = open('dog_breeds.txt')
try:
    # 在這兒做進一步的文件處理
finally:
    reader.close()

如果您不熟悉try-finally塊的內容，請查看Python Exceptions：An Introduction。

關閉文件的第二種方法是使用如下的with語句：

with open('dog_breeds.txt') as reader:
    # 在這兒做進一步的文件處理

WITH語句在離開WITH塊后自動負責關閉文件，即使在出現錯誤的情況下也是如此。我強烈建議您盡可能多地使用WITH語句，因為它允許使用更干凈的代碼，并使您更容易處理任何意外錯誤。

最有可能的是，你也想要使用第二個位置參數mode。此參數是一個字符串，其中包含多個字符以表示您要如何打開文件。默認值和最常見的是'r'，表示以只讀模式將文件作為文本文件打開：

with open('dog_breeds.txt', 'r') as reader:
    # 在這兒做進一步的文件處理

其他模式選項參見: 在線完整記錄，但最常用的選項如下：

讓我們回過頭來談談文件對象。文件對象是：

“將面向文件的API（使用read()或write()等方法）暴露給底層資源的對象。”（定義來源）

有三種不同類別的文件對象：

• 文本文件
• 緩沖的二進制文件
• 原始二進制文件

這些文件類型中的每一種都在io模塊中定義。這里簡要介紹下如何排列。

文本文件類型

文本文件是最常見的文件。以下是一些如何打開這些文件的示例：

open('abc.txt')

open('abc.txt', 'r')

open('abc.txt', 'w')

使用這些類型的文件，open()將返回一個TextIOWrapper文件對象：

>>> file = open('dog_breeds.txt')
>>> type(file)
<class '_io.TextIOWrapper'>

這是open()返回的默認文件對象。

緩沖二進制文件類型

緩沖二進制文件類型用于讀取和寫入二進制文件。以下是一些如何打開這些文件的示例：

open('abc.txt', 'rb')

open('abc.txt', 'wb')

使用這些類型的文件，open()將返回一個BufferedReader或BufferedWriter文件對象：

>>> file = open('dog_breeds.txt', 'rb')
>>> type(file)
<class '_io.BufferedReader'>
>>> file = open('dog_breeds.txt', 'wb')
>>> type(file)
<class '_io.BufferedWriter'>

原始二進制文件類型

原始文件類型是：

“通常用作二進制和文本流的低級構建塊。”（定義來源）

因此通常不使用它。

以下是如何打開這些文件的示例：

open('abc.txt', 'rb', buffering=0)

使用這些類型的文件，open()將返回一個FileIO文件對象：

>>> file = open('dog_breeds.txt', 'rb', buffering=0)
>>> type(file)
<class '_io.FileIO'>

讀寫打開的文件

打開文件后，您將需要讀取或寫入文件。首先，讓我們來讀取一個文件。可以在文件對象上調用多種方法來幫助您：

使用上面使用的相同文件dog_breeds.txt，我們來看一些如何使用這些方法的示例。以下是如何使用.read()命令打開和讀取整個文件的示例：

>>> with open('dog_breeds.txt', 'r') as reader:
>>>     # 讀取并打印整個文件
>>>     print(reader.read())
Pug
Jack Russel Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier

這是一個如何使用.readline()每行讀取5個字節的示例：

>>> with open('dog_breeds.txt', 'r') as reader:
>>>     # 讀取并打印一行的前5個字符, 重復5次
>>>     print(reader.readline(5))
>>>     # 請注意，一行大于5個字符，就沿該行繼續，
>>>     # 每次讀取5個字符，直到行尾，然后“換行”
>>>     print(reader.readline(5))
>>>     print(reader.readline(5))
>>>     print(reader.readline(5))
>>>     print(reader.readline(5))
Pug

Jack
Russe
ll Te
rrier

以下是使用.readlines()方法將整個文件作為列表讀取的示例：

>>> f = open('dog_breeds.txt')
>>> f.readlines()  # 返回一個列表
['Pug\n', 'Jack Russel Terrier\n', 'English Springer Spaniel\n', 'German Shepherd\n', 'Staffordshire Bull Terrier\n', 'Cavalier King Charles Spaniel\n', 'Golden Retriever\n', 'West Highland White Terrier\n', 'Boxer\n', 'Border Terrier\n']

上面的例子也可以通過使用list()從文件對象創建列表來完成：

>>> f = open('dog_breeds.txt')
>>> list(f)
['Pug\n', 'Jack Russel Terrier\n', 'English Springer Spaniel\n', 'German Shepherd\n', 'Staffordshire Bull Terrier\n', 'Cavalier King Charles Spaniel\n', 'Golden Retriever\n', 'West Highland White Terrier\n', 'Boxer\n', 'Border Terrier\n']

迭代文件中的每一行

讀取文件時常見的事情是迭代每一行。以下是如何使用.readline()執行迭代的示例：

>>> with open('dog_breeds.txt', 'r') as reader:
>>>     # 一行接一行地讀取和打印整個文件
>>>     line = reader.readline()
>>>     while line != '':  # EOF為空
>>>         print(line, end='')
>>>         line = reader.readline()
Pug
Jack Russel Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier

您可以迭代文件中每一行的另一種方法是使用.readlines()文件對象。請記住，.readlines()返回一個列表，其中列表中的每個元素代表文件中的一行：

>>> with open('dog_breeds.txt', 'r') as reader:
>>>     for line in reader.readlines():
>>>         print(line, end='')
Pug
Jack Russell Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier

但是，通過迭代文件對象本身可以進一步簡化上述示例：

>>> with open('dog_breeds.txt', 'r') as reader:
>>>     # Read and print the entire file line by line
>>>     for line in reader:
>>>         print(line, end='')
Pug
Jack Russel Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier

最后的方法更Pythonic，可以更快，更高效。因此，建議您改用它。

:exclamation: 注意：

上面的一些示例包含print('some text', end='')。這end=''是為了防止Python為正在打印的文本添加額外的換行符，并僅打印從文件中讀取的內容。

現在讓我們深入研究文件。與讀取文件一樣，文件對象有多種方法可用于寫入文件：

以下是使用.write()和.writelines()的簡單示例：

with open('dog_breeds.txt', 'r') as reader:
    # 注意：readlines 不裁剪行尾
    dog_breeds = reader.readlines()

with open('dog_breeds_reversed.txt', 'w') as writer:
    # 你也可以用
    # writer.writelines(reversed(dog_breeds))

    # 把狗的品種按相反的順序寫入文件
    for breed in reversed(dog_breeds):
        writer.write(breed)

使用字節

有時，您可能需要使用字節字符串處理文件。這是通過在mode參數中添加'b'字符來完成的。文件對象的所有相同方法都適用。但是，每個方法都期望并返回一個bytes對象:

>>> with open(`dog_breeds.txt`, 'rb') as reader:
>>>     print(reader.readline())
b'Pug\n'

使用b標志打開文本文件并不那么有趣。假設我們有一張 杰克拉塞爾梗（jack_russell.png）的可愛圖片：

jack_russell.92348cb14537.png

圖片：CC BY 3.0（https://creativecommons.org/licenses/by/3.0）]，來自Wikimedia Commons

您實際上可以在Python中打開該文件并檢查內容！由于.png文件格式定義良好，文件的標題是8個字節，如下所示：

果然，當您打開文件并單獨讀取這些字節時，您可以看到這確實是一個.png頭文件：

>>> with open('jack_russell.png', 'rb') as byte_reader:
>>>     print(byte_reader.read(1))
>>>     print(byte_reader.read(3))
>>>     print(byte_reader.read(2))
>>>     print(byte_reader.read(1))
>>>     print(byte_reader.read(1))
b'\x89'
b'PNG'
b'\r\n'
b'\x1a'
b'\n'

一個完整的例子： dos2unix.py

讓我們把這整件事情捋一遍，看看如何讀取和寫入文件的完整示例。下面是一個類似dos2unix的工具，它將把包含\r\n行尾的文件轉換為\n。

該工具分為三個主要部分。第一個是str2unix()將字符串從\\r\\n行結尾轉換為\\n。第二個是dos2unix()將包含\r\n字符的字符串轉換為\n。dos2unix()調用str2unix()。最后，有__main__塊，只有當文件作為腳本執行時才會調用。可以將其視為其他編程語言中的main功能。

"""
一個簡單的腳本和庫, 
用來把文件或字符從dos樣式行結尾轉換為Unix樣式行結尾
"""

import argparse
import os


def str2unix(input_str: str) -> str:
    r"""\
    把 \r\n 行結尾字符串轉換為 \n 行結尾

    Parameters
    ----------
    input_str
        行結尾將被轉換的整個字符串

    Returns
    -------
        轉換后的字符串
    """
    r_str = input_str.replace('\r\n', '\n')
    return r_str


def dos2unix(source_file: str, dest_file: str):
    """\
    轉換包含Dos樣式的行結尾文件為Unix樣式

    Parameters
    ----------
    source_file
        要被轉換的源文件路徑
    dest_file
        轉換后的文件輸出路徑
    """
    # NOTE: 可以添加文件是否存在檢查和文件覆蓋保護
    with open(source_file, 'r') as reader:
        dos_content = reader.read()

    unix_content = str2unix(dos_content)

    with open(dest_file, 'w') as writer:
        writer.write(unix_content)


if __name__ == "__main__":
    # 創建Argument parser并設置描述
    parser = argparse.ArgumentParser(
        description="把Dos樣式文件轉換為Unix樣式文件的腳本",
    )

    # Add the arguments:
    #   - source_file: 想要轉換的源文件
    #   - dest_file: 輸出文件目的地

    # Note: the use of the argument type of argparse.FileType could
    # streamline some things
    parser.add_argument(
        'source_file',
        help='源文件路徑 '
    )

    parser.add_argument(
        '--dest_file',
        help='目的文件路徑(default: source_file appended with `_unix`',
        default=None
    )

    # Parse the args (argparse automatically grabs the values from
    # sys.argv)
    args = parser.parse_args()

    s_file = args.source_file
    d_file = args.dest_file

    # 如果沒有傳遞目的文件, 
    # 那么我們會自動基與源文件創建一個新文件
    if d_file is None:
        file_path, file_extension = os.path.splitext(s_file)
        d_file = f'{file_path}_unix{file_extension}'

    dos2unix(s_file, d_file)

提示和技巧

現在您已經掌握了讀寫文件的基礎知識，這里有一些提示和技巧可以幫助您提高技能。

__file__

__file__屬性是模塊的特殊屬性，類似于__name__。它是：

“從中加載模塊的文件的路徑名（如果從文件加載模塊的話）”（來源)

:exclamation: 注意：

要重新迭代，__file__返回相對于調用初始Python腳本的路徑。如果需要完整的系統路徑，可以使用os.getcwd()獲取執行代碼的當前工作目錄。

這是一個真實世界的例子。在我過去的一份工作中，我對硬件設備進行了多次測試。每個測試都是使用Python腳本編寫的，測試腳本文件名用作標題。然后執行這些腳本并使用__file__特殊屬性打印其狀態。這是一個示例文件夾結構：

project/
|
├── tests/
|   ├── test_commanding.py
|   ├── test_power.py
|   ├── test_wireHousing.py
|   └── test_leds.py
|
└── main.py

運行main.py產生以下內容：

>>> python main.py
tests/test_commanding.py Started:
tests/test_commanding.py Passed!
tests/test_power.py Started:
tests/test_power.py Passed!
tests/test_wireHousing.py Started:
tests/test_wireHousing.py Failed!
tests/test_leds.py Started:
tests/test_leds.py Passed!

通過使用__file__特殊屬性，我能夠運行并動態獲取所有測試的狀態。

附加到文件

有時，您可能希望附加到文件或在已填充文件的末尾開始寫入。這可以通過使用mode參數的'a'輕松完成：

with open('dog_breeds.txt', 'a') as a_writer:
    a_writer.write('\nBeagle')

當您再次檢查dog_breeds.txt時，您將看到文件的開頭未更改，Beagle現在已添加到文件的末尾：

>>> with open('dog_breeds.txt', 'r') as reader:
>>>     print(reader.read())
Pug
Jack Russel Terrier
English Springer Spaniel
German Shepherd
Staffordshire Bull Terrier
Cavalier King Charles Spaniel
Golden Retriever
West Highland White Terrier
Boxer
Border Terrier
Beagle

同時使用兩個文件

有時您可能想要讀取文件并同時寫入另一個文件。如果您在學習如何寫入文件時同時顯示的示例，則可以將其實際組合為以下內容：

d_path = 'dog_breeds.txt'
d_r_path = 'dog_breeds_reversed.txt'
with open(d_path, 'r') as reader, open(d_r_path, 'w') as writer:
    dog_breeds = reader.readlines()
    writer.writelines(reversed(dog_breeds))

創建自己的Context Manager

可能有一段時間，您需要通過將文件對象放在自定義類中來更好地控制文件對象。執行此操作時，除非添加一些魔術方法__enter__和__exit__，否則無法再使用with語句. 通過添加這些，您將創建所謂的上下文管理器(Context Manager)。

調用with語句時會調用__enter__()。從with語句塊退出時調用__exit__()。

這是一個可用于制作自定義類的模板：

class my_file_reader():
    def __init__(self, file_path):
        self.__path = file_path
        self.__file_object = None

    def __enter__(self):
        self.__file_object = open(self.__path)
        return self

    def __exit__(self, type, val, tb):
        self.__file_object.close()

    # Additional methods implemented below

現在您已經擁有了上下文管理器的自定義類，您可以通過類似內置的open()的方式來使用它：

with my_file_reader('dog_breeds.txt') as reader:
    # Perform custom class operations
    pass

這是一個很好的例子。還記得我們有可愛的杰克羅素形象嗎？也許你想打開其他.png文件，但不想每次都解析頭文件。這是一個如何做到這一點的例子。此示例還使用自定義迭代器。如果您不熟悉它們，請查看Python迭代器：

class PngReader():
    # 每個 .png 文件都包含相同的頭文件.  
    # 使用它來驗證該文件確實是 png
    _expected_magic = b'\x89PNG\r\n\x1a\n'

    def __init__(self, file_path):
        # 確保文件有正確的擴展名
        if not file_path.endswith('.png'):
            raise NameError("File must be a '.png' extension")
        self.__path = file_path
        self.__file_object = None

    def __enter__(self):
        self.__file_object = open(self.__path, 'rb')

        magic = self.__file_object.read(8)
        if magic != self._expected_magic:
            raise TypeError("The File is not a properly formatted .png file!")

        return self

    def __exit__(self, type, val, tb):
        self.__file_object.close()

    def __iter__(self):
        # This and __next__() are used to create a custom iterator
        # See https://dbader.org/blog/python-iterators
        return self

    def __next__(self):
        # Read the file in "Chunks"
        # See https://en.wikipedia.org/wiki/Portable_Network_Graphics#%22Chunks%22_within_the_file

        initial_data = self.__file_object.read(4)

        # The file hasn't been opened or reached EOF.  This means we
        # can't go any further so stop the iteration by raising the
        # StopIteration.
        if self.__file_object is None or initial_data == b'':
            raise StopIteration
        else:
            # Each chunk has a len, type, data (based on len) and crc
            # Grab these values and return them as a tuple
            chunk_len = int.from_bytes(initial_data, byteorder='big')
            chunk_type = self.__file_object.read(4)
            chunk_data = self.__file_object.read(chunk_len)
            chunk_crc = self.__file_object.read(4)
            return chunk_len, chunk_type, chunk_data, chunk_crc

現在可以打開.png文件并使用自定義上下文管理器正確分析它們：

>>> with PngReader('jack_russell.png') as reader:
>>>     for l, t, d, c in reader:
>>>         print(f"{l:05}, {t}, {c}")
00013, b'IHDR', b'v\x121k'
00001, b'sRGB', b'\xae\xce\x1c\xe9'
00009, b'pHYs', b'(<]\x19'
00345, b'iTXt', b"L\xc2'Y"
16384, b'IDAT', b'i\x99\x0c('
16384, b'IDAT', b'\xb3\xfa\x9a$'
16384, b'IDAT', b'\xff\xbf\xd1\n'
16384, b'IDAT', b'\xc3\x9c\xb1}'
16384, b'IDAT', b'\xe3\x02\xba\x91'
16384, b'IDAT', b'\xa0\xa99='
16384, b'IDAT', b'\xf4\x8b.\x92'
16384, b'IDAT', b'\x17i\xfc\xde'
16384, b'IDAT', b'\x8fb\x0e\xe4'
16384, b'IDAT', b')3={'
01040, b'IDAT', b'\xd6\xb8\xc1\x9f'
00000, b'IEND', b'\xaeB`\x82'

不要重復造輪子

在處理文件時可能會遇到常見情況。大多數情況可以使用其他模塊處理。您可能需要使用的兩種常見文件類型是.csv和.json。Real Python已經匯總了一些關于如何處理這些內容的精彩文章：

• 用Python讀寫CSV文件
• 在Python中使用JSON數據

此外，還有內置庫，您可以使用它們來幫助您：

• wave：讀寫WAV文件（音頻）
• aifc：讀寫AIFF和AIFC文件（音頻）
• sunau：讀取和寫入Sun AU文件
• tarfile：讀取和寫入tar歸檔文件
• zipfile：使用ZIP存檔
• configparser：輕松創建和解析配置文件
• xml.etree.ElementTree：創建或讀取基于XML的文件
• msilib：讀取和寫入Microsoft Installer文件
• plistlib：生成并解析Mac OS X .plist文件

還有更多的東西。此外，PyPI還有更多第三方工具可用。一些流行的是以下：

• PyPDF2：PDF工具包
• xlwings：讀取和寫入Excel文件
• Pillow：圖像閱讀和操作

結束語

你做到了！您現在知道如何使用Python處理文件，包括一些高級技術。使用Python中的文件現在比以往任何時候都更容易，當你開始這樣做時，這是一種有益的感覺。

在本教程中，您已經了解到：

• 什么是文件
• 如何正確打開和關閉文件
• 如何讀寫文件
• 使用文件時的一些高級技術
• 一些庫使用常見的文件類型

如果您有任何疑問，請在評論中與我們聯系。