Python open file: Python Directory and Files Management (With Examples)

Следующий код показывает , как открыть текстовый файл для чтения в Python. В данном примере нас открытие файла с использованием абсолютного пути .

Абсолютный путь содержит полный путь к файлу или каталогу, к которому нам нужно получить доступ. Он включает в себя полный список каталогов, необходимых для поиска файла.

Например, /home/reports/samples.txt — это абсолютный путь для обнаружения файла sample.txt. Вся информация, необходимая для поиска файла, содержится в строке пути.

См. прикрепленный файл, используемый в примере, и изображение, показывающее содержимое файла для справки.

 # Открытие файла с абсолютным путем
fp = open(r'E:\demos\files\sample.txt', 'r')
# прочитать файл
печать (fp.read())
# Закрываем файл после прочтения
fp.close()
# путь, если вы используете MacOs
# fp = open(r"/Users/myfiles/sample.txt", "r") 

Вывод

 Добро пожаловать на PYnative.com
Это пример.txt 

Открытие файла с относительным путем

Относительный путь — это путь, который начинается с рабочего каталога или текущего каталога, а затем начинается поиск файла из этого каталога по имени файла.

Например, reports/sample.txt — это относительный путь. В относительном пути он будет искать файл в каталоге, в котором запущен этот скрипт.

 # Открытие файла с относительным путем
пытаться:
    fp = открыть ("sample.txt", "r")
    печать (fp.read())
    fp.close()
кроме FileNotFoundError:
    print("Пожалуйста, проверьте путь.") 

Обработка

Если мы пытаемся открыть файл, которого нет по указанному пути, мы получим

 fp = открыть (r'E:\demos\files\reports.txt', 'r')
print(f.read()) 

Вывод

 FileNotFoundError: [Errno 2] Нет такого файла или каталога: 'E:\demos\files\reports.txt' 

Мы можем обработать ошибку "файл не найден" внутри блок try-except. Давайте посмотрим на пример того же. Используйте блок, кроме блока, чтобы указать действие, которое должно быть выполнено, когда указанный файл отсутствует.

 попробуйте:
    fp = open(r'E:\PYnative\reports\samples. txt', 'r')
    печать (fp.read())
    fp.close()
кроме IOError:
    print("Файл не найден. Пожалуйста, проверьте путь.")
Ну наконец то:
    печать("Выход") 

Вывод

 Файл не найден. Пожалуйста, проверьте путь.
Выход 

Функция File open()

Python предоставляет набор встроенных функций, доступных в интерпретаторе, и он всегда доступен. Для этого нам не нужно импортировать какой-либо модуль. Мы можем открыть файл с помощью встроенной функции open().

Синтаксис файла open() function

 open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None) 

Возвращает файловый объект, который мы можем использовать для чтения или записи в файл.

Параметры :

Давайте посмотрим, какие параметры мы можем передать функции open() для улучшения работы с файлами.

Параметр	Описание
файл	Значение этого параметра задает путь (абсолютный или относительный к текущему рабочему каталогу) для открываемого файла.
режим	Это необязательная строка, указывающая режим, в котором будет открыт файл. Значение по умолчанию — 'r' для чтения текстового файла. Мы можем обсудить другие режимы в следующем разделе.
буферизация	Это необязательное целое число, используемое для установки политики буферизации. Передайте 0, чтобы отключить буферизацию (разрешено только в двоичном режиме), 1, чтобы выбрать буферизацию строк (можно использовать только в текстовом режиме), и целое число > 1, чтобы указать размер в байтах буфера фрагмента фиксированного размера.
кодировка	Это имя кодировки, используемой для декодирования или кодирования файла. Значение по умолчанию зависит от платформы.
ошибки	Это необязательная строка, обозначающая, как должны обрабатываться стандартные ошибки кодирования и декодирования.
новая строка	Этот параметр указывает, как работает режим новой строки (применяется только к текстовому режиму). Это может быть Нет , '' , '\n' , '\r' и '\r\n' .
closefd	Этот параметр указывает, закрывать дескриптор файла или нет. Значение по умолчанию верно. Если closefd  равно False и был задан файловый дескриптор, а не имя файла, базовый файловый дескриптор останется открытым при закрытии файла.

Открытие файла в режиме чтения

Мы можем открыть файл для чтения содержимого файла, используя функцию

Файл может быть в основном двух категорий, а именно плоские файлы и неплоские файлы.

• Плоские файлы — это файлы, которые не проиндексированы должным образом, например . csv (значения, разделенные запятыми), где каждая запись имеет разные значения, разделенные запятыми. Но они не упорядочены с индексом. Как правило, они имеют одну запись в строке и, как правило, имеют фиксированный набор значений в каждой записи.
• Неплоские файлы — это файлы с правильными значениями индекса. Каждая запись будет иметь одно значение индекса, и мы можем легко найти его, используя значение индекса.

Учтите, что у нас есть файл с именем «sample.txt», и мы открываем его для чтения его содержимого.

 попробуйте:
    fp = открыть ("sample.txt", "r")
    # Чтение содержимого файла и закрытие
    печать (fp.read())
    fp.close()
кроме IOError:
    print("Пожалуйста, проверьте путь.") 

Вывод

 Добро пожаловать на PYnative.com
Это sample.txt 

Подробнее : Полное руководство по чтению файлов в Python

Открытие файла в режиме записи

Мы можем открыть файл для записи нового содержимого в файл с помощью функции open() с w в качестве режима доступа . Курсор или указатель файла будет помещен в начало файла .

Примечание : Если файл уже существует, он будет обрезан, что означает, что все содержимое, ранее находившееся в файле, будет удалено, а новое содержимое будет добавлено в файл.

 fp = открыть ("sample2.txt", "w")
# Написание контента
fp.write("Новая строка")
# Снова открываем файл для чтения содержимого
fp = открыть ("sample2.txt", "r")
# Чтение содержимого файла и закрытие
печать (fp.read())
: Полное руководство по записи в файл в Python используя  open() , передав символ   a  в качестве режима доступа  . Курсор будет помещен  в конец файла , а новый контент будет добавлен в конец. 
 
 Разница между этим режимом и режимом записи заключается в том, что в этом режиме содержимое файла не будет обрезано или удалено. 
 
 Учтите, что файл «sample2.txt» уже создан и в нем есть содержимое. Теперь мы открываем файл в режиме добавления и пытаемся добавить содержимое в конец файла.  
 
 # Открыть и добавить наконец
fp = открыть ("sample2.txt", "а")
fp.write("Добавил эту строку, открыв файл в режиме добавления")
# Снова открываем файл для чтения
fp = открыть ("sample2.txt", "r")
печать (fp.read())
fp.close() 
  
  Вывод 
 Новая строка
Добавил эту строку, открыв файл в режиме добавления 
Образец текстового файла после записи
 Закрытие файла 
 Нам нужно убедиться, что файл будет правильно закрыт после завершения файловой операции. Оставлять файлы открытыми — плохая практика.
 В Python очень важно закрыть файл после завершения работы в основном по следующим причинам: –
 Это освобождает ресурсы, которые были связаны с файлом. Благодаря этому пространство в ОЗУ может быть лучше использовано и обеспечивает лучшую производительность.
 Обеспечивает лучшую сборку мусора.
 Существует ограничение на количество открытых файлов в приложении. Всегда лучше закрыть файл, чтобы убедиться, что лимит не превышен.
 
 
 Если вы открываете файл в режиме записи или чтения-записи, вы не знаете, когда данные сбрасываются.
 Файл можно закрыть, просто вызвав функцию  close()  следующим образом.
 # Открытие файла для чтения содержимого
f = открыть ("sample2.txt", "r")
печать (f.read())
# Закрытие файла после завершения нашей работы
f.close() 
 Мы можем открыть файл, используя оператор with вместе с функцией открытия. Общий синтаксис следующий.
 с open(__file__, accessmode) as f: 
 Ниже приведены основные преимущества открытия файла с помощью  с оператором 
 Оператор with упрощает обработку исключений, инкапсулируя общие задачи подготовки и очистки.
 Это также обеспечивает автоматическое закрытие файла после выхода из блока.
 Поскольку файл  закрывается автоматически , это гарантирует, что все ресурсы, связанные с файлом, будут освобождены.
  
 Давайте посмотрим, как мы можем использовать оператор with для открытия файла на примере. Предположим, что есть два файла «sample.txt» и «sample2.txt», и мы хотим скопировать содержимое первого файла во второй.
 # Открытие файла
с open('sample.txt', 'r', encoding='utf-8') в качестве входного файла, open('sample2.txt', 'w') в качестве внешнего файла:
    # прочитать sample.txt и записать его содержимое в sample2.txt
    для строки в файле:
        outfile.write(строка)
# Открытие файла для чтения содержимого
f = открыть ("Sample2.txt", "r")
печать (f.read())
f.close() 
  Вывод 
 Добро пожаловать на PYnative.com
Файл, созданный для демонстрации работы с файлами в Python 
 Здесь мы видим, что содержимое файла sample2.txt было заменено содержимым файла sample.txt.
 Создание нового файла 
 Мы можем создать новый файл, используя 
  функцию open() , установив  режим  x   . Этот метод гарантирует, что файл еще не существует, а затем создает новый файл. Это вызовет ошибку  FileExistsError , если файл уже существует.
  Пример  : Создание нового файла.
 попробуйте:
    # Создание нового файла
    с open("sample3.txt", "x") как fp:
        fp.write("Привет, мир! Я новый файл")
    # чтение содержимого нового файла
    fp = открыть ("sample3.txt", "r")
    печать (fp.read())
кроме FileExistsError:
    print("Файл уже существует") 
  Выход 
 Привет, мир! Я новый файл 
 Открытие файла для нескольких операций 
 В Python мы можем открыть файл для одновременного выполнения нескольких операций с помощью оператора  '+' . Когда мы передаем режим  r+ , он включает параметры чтения и записи в файле. Давайте посмотрим на это на примере.
  
 с открытым ("Sample3.txt", "r+") как fp:
    # чтение содержимого перед записью
    печать (fp.read())
    # Запись нового содержимого в этот файл
    fp.write("\nДобавление нового контента") 
 Открытие двоичного файла 
 Двоичные файлы в основном содержат данные в байтовом формате (0 и 1). Обычно он не содержит EOL (конец строки), поэтому важно проверить это условие перед чтением содержимого файла.
 Мы можем открыть и прочитать содержимое двоичного файла, как показано ниже.
 с open("sample.bin", "rb") как f:
    byte_content = f.read(1)
    в то время как byte_content:
        # Печать содержимого файла
        печать (byte_content)
 
 Резюме 
 В этом руководстве мы рассмотрели, как открыть файл, используя различные режимы доступа. Кроме того, мы узнали о важности открытия файла с помощью оператора with.
 Python close() File — правильное открытие и закрытие файлов — LearnDataSci Самый простой способ открытия и закрытия файлов описан ниже. 
 file = open('example_file.txt') # открыть файл примера
file.close() # закрыть его 
 Одна из самых распространенных ошибок, которую люди допускают при использовании файлов в Python, заключается в том, что они не закрываются после этого.
  В этом уроке мы рассмотрим некоторые проблемы, вызванные тем, что файлы остаются открытыми, и способы их предотвращения, используя общепринятые рекомендации.
 Незакрытие файла после взаимодействия — это не только пустая трата ресурсов программы, но также может предотвратить другие взаимодействия с файлами и привести к несоответствиям при выполнении сценариев в разных версиях Python. Оставлять файлы открытыми также считается плохой практикой, и всегда лучше завести хорошие привычки как можно раньше.
 Представьте, что у вас есть файл с именем  file_1.txt , который хранится в том же каталоге, что и ваш скрипт Python. Этот файл содержит текст «Это текст файла 1».
 Вы хотите прочитать файл в Python, отобразить текст и добавить новую строку, чтобы отметить, что вы прочитали текстовый файл. Этот процесс показан (неверно) ниже:
 file = open('file_1.txt','r') # файл открыт в режиме чтения (r)
печать (файл. чтение())
file = open('file_1.txt', 'a') # файл открывается в режиме добавления (a)
file.write(' и мы его прочитали.')
file = open('file_1.txt','r') # файл открывается в режиме чтения (r)
печать (файл.чтение())
файл.close() 
 Исходящий:
 Это файл 1 текст
Это текст файла 1, и мы его прочитали. 
 Файл был правильно закрыт, верно?  Неправильно. 
 В этом примере мы закрыли файл только после последнего открытия. Для некоторых версий Python используемый код может неправильно записывать добавленный текст, поскольку файл не был закрыт после завершения операции. Чтобы продемонстрировать это, посмотрите, что произойдет, если мы попытаемся закрыть каждый файл по отдельности в качестве решения:
 f1 = открыть('file_1.txt','r')
печать (f1.read())
f2 = открыть('файл_1.txt', 'а')
f2.write(' и мы это прочитали. ')
f3 = открыть('file_1.txt','r')
печать (f3.read())
f1.закрыть()
f2.закрыть()
f3.close() 
 Out:
 Это текст файла 1
Это текст файла 1 
 Мы видим, что добавление к файлу из  f2  не отражено в  f3  .
 Подобное кодирование также может потенциально повредить файл, препятствуя его чтению или повторному использованию в будущем. Этот пример прост, но если бы вы писали сценарий, который добавлял дополнительную информацию к длинному файлу, заполненному ценными данными о клиентах, или данными, на изучение которых ушли месяцы, повреждение файла стало бы дорогостоящей проблемой.
 Чтобы исправить этот пример, нам нужно убедиться, что файл закрыт после записи, прежде чем пытаться прочитать его снова:
 f1 = open('file_1.txt','r')
печать (f1.read())
f1.закрыть()
f2 = открыть('файл_1. txt', 'а')
f2.write(' и мы это прочитали.')
f2.закрыть()
f3 = открыть('file_1.txt','r')
печать (f3.read())
f3.close() 
 Out:
 Это текст файла 1
Это текст файла 1, и мы его прочитали. 
 Более простой альтернативой ручной обработке  .close()  для каждого файла является использование менеджера контекста.
 Чтобы закрыть свойство файлов, самое простое решение, соответствующее рекомендациям, — это использовать так называемый оператор  с  при каждом открытии файла. Этот шаблон также известен как использование менеджера контекста, фундаментальной концепции Python.
 Ниже приведен пример использования оператора  с оператором , чтобы убедиться, что файлы закрыты:
 с open('file_1.txt','r') as f:
    печать (f.read())
с open('file_1.txt', 'a') как f:
    f. write(' и мы это прочитали.')
с open('file_1.txt','r') как f:
    печать(f.read()) 
 Исходящий:
 Это текст файла 1, и мы его прочитали.
Это текст файла 1, и мы его прочитали. и мы прочитали это. 
 Обновленный код обеспечивает ту же функциональность при меньшем объеме кода. Использование  с оператором open()  автоматически закроет файл после завершения блока.
 Использование менеджера контекста не только избавит вас от необходимости помнить о закрытии файлов вручную, но также значительно облегчит другим людям, читающим ваш код, возможность точно увидеть, как программа использует файл.
 Использование  с open()  часто является правильным выбором, но могут быть ситуации, когда ваш проект может потребовать закрытия файлов вручную.
 При использовании менеджера контекста может возникнуть несколько ошибок. Одним из примеров этого является  ValueError: операция ввода-вывода в закрытом файле  . Рассмотрим код ниже:
 с open('file_2.txt', 'a') как f:
    message = 'Это текст файла 2'
f.write(сообщение) 
 Исходящий:
 ----------------------------------------------------- -------------------------------------
ValueError Traceback (последний последний вызов)
 в <модуле>
      1 с open('file_2.txt', 'w') как f:
      2 сообщение = 'Это текст файла 2'
----> 3 f.write(сообщение)
ValueError: операция ввода-вывода в закрытом файле. 
 Эта ошибка возникает из-за того, что мы использовали файловую операцию  write()  за пределами  с областью действия open() . Поскольку диспетчер контекста автоматически закрывает файл после выполнения кода с отступом, Python не может выполнять какие-либо последующие операции с файлами. Мы можем легко решить эту проблему, оставив все под  с областью действия open() , например:
 с open('file_2. txt', 'a') как f:
    message = 'Это текст файла 2'
    f.write(сообщение) 
 Новый сценарий выполняется успешно, записывая сообщение в файл перед его закрытием.
 Любому, кто работает с Python, скорее всего, придется много работать с файлами. Неотъемлемой частью взаимодействия с файлами является обязательное закрытие их после завершения работы!
 Если оставить файлы открытыми, это может вызвать множество проблем, особенно в больших проектах, использующих большое количество файлов.
 Как мы уже говорили, простой способ избежать осложнений, которые потенциально может вызвать оставление файлов открытыми, — это открывать файлы с помощью менеджера контекста, который автоматически закрывает файлы для вас. Следование этому шаблону сэкономит вам работу, предотвратив напрасную трату ресурсов и несоответствие версий. Самое главное, используя  с операторами  поможет сделать ваш код чистым и профессиональным.
 Начать обучение бесплатно
 Познакомьтесь с авторами 
  Алфи Грейс   Специалист по данным 
 Алфи получила степень магистра машиностроения в Университетском колледже Лондона.