Работа с файлами в питоне: Работа с файлами

Работа с файлами в Python: функция open()

Главная / Блог / Работа с файлами в Python

Дата: 15 октября 2020

Автор: Михаил Макарик

Следить за результатами выполнения скрипта в консоли информативно, но не очень весело. Более того, после закрытия терминала весь итог работы кода исчезает. А хочется сохранить всё это куда-то на диск, чтобы потом в любое время рассмотреть повнимательнее. Да и простая задача «работать с файлами» может возникнуть в любое время.

В языке Python для этого предусмотрена встроенная функция open(). Она дает возможность чтения и записи файлов. Об этом ниже.

1. Начало работы

В качестве примера работы с файлами на ПК мы будем использовать war_and_peace.txt (начало романа Л. Н. Толстого «Война и мир»), который разместим в папке скрипта.

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

Пример – Интерактивный режим

>>> file = open('war_and_peace.txt') 
>>> file.read(50) 
†Eh bien, mon prince. Gênes et Lucques ne s 
>>> file.read() 
Тут выведется оставшаяся часть текста... 
>>> file.read() 
Получим пустую строку 
>>> file.close() 

Рассмотрим подробнее проделанные операции.

1. Мы открыли файл ‘war_and_peace.txt’ и присвоили его переменной file.

2. Далее мы вывели на печать первые 50 символов объекта. Если в метод

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

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

Читайте также

Кодирование строк — ASCII, Unicode, UTF-8

Чтобы компьютер смог отобразить передаваемые ему символы, они должны быть представлены в конкретной кодировке. Навряд ли найдется человек, который никогда не сталкивался с кракозябрами: открываешь интернет-страницу, а там – набор непонятных знаков; хочешь прочесть книгу в текстовом редакторе, а вместо слов получаешь сплошные знаки вопроса. Причина заключается в неверной процедуре декодирования текста…

Программирование на Python. Урок 4. Работа со строками

Строки в Python. Тип данных: str. Учимся выполнять основные действия над строковым типом данных в Python: создание, экранирование, конкатенация и умножение, срезы, форматирование, строковые методы.

2. Чтение файла целиком

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

Попытаемся еще раз открыть файл, указав кодировку, режим (на чтение обозначается буквой r).

Пример – Интерактивный режим

>>> with open('war_and_peace.txt', 'r', encoding='utf-8') as file:
           txt = file.read()
>>> txt[:50]
\ufeff— Eh bien, mon prince. Gênes et Lucques ne sont p
>>> txt[:50]
\ufeff— Eh bien, mon prince. Gênes et Lucques ne sont p

В данном случае код вне контекстного менеджера выполняется после закрытия файлового объекта и очистки памяти (даже если бы возникла ошибка).

Существует второй способ чтения файла целиком: через метод readlines(). Он возвращает список строк. Строки идентифицируются по символу ‘\n’.

Пример – Интерактивный режим

>>> with open('war_and_peace.txt', 'r', encoding='utf-8') as file:
           txt = file.readlines()
>>> txt[0]
"\ufeff— Eh bien, mon prince. Gênes et Lucques ne sont plus que des apanages, des поместья, de la famille Buonaparte. Non, je vous préviens que si vous ne me dites pas que nous avons la guerre, si vous vous permettez encore de pallier toutes les infamies, toutes les atrocités de cet Antichrist (ma parole, j'y crois) — je ne vous connais plus, vous n'êtes plus mon ami, vous n'êtes plus мой верный раб, comme vous dites 1.   Ну, здравствуйте, здравствуйте. Je vois que je vous fais peur 2, садитесь и рассказывайте.\n"

Здесь мы вывели на печать первую строку файла.

Итак, теперь текст отображается правильно. Но, имеется еще один неприятный момент, на который не каждый обратит внимание. Наш файл – достаточно мал по объему. Поэтому мы оправданно присвоили всё его содержимое одной переменной. В случае огромных объектов (например, HD-фильм или база данных на сотню миллионов пользователей) это чревато переполнением памяти и возникновением ошибок.

3. Чтение файла частями

К счастью, файловый объект может читаться построчно при помощи readline(). Следовательно, мы можем посмотреть каждую строку тяжеловесного файла и проделать над ней какие-то операции.

Выведем на печать первые 50 символов двух первых строк.

Пример – Интерактивный режим

>>> with open('war_and_peace. txt', 'r', encoding='utf8') as file:
           first_line = file.readline()
           second_line = file.readline()
>>> first_line[:50]
\ufeff— Eh bien, mon prince. Gênes et Lucques ne sont p
>>> second_line[:50]
Так говорила в июле 1805 года известная Анна Павло

Такой способ удобен, если нам не нужен весь файл, а лишь его часть. Главный минус – мы можем не знать, сколько строк в файле. А так как

Если методу readline() передать числовой аргумент, то он посчитает окончанием строки это количество символов.

Чтение по строкам можно провести обычной итерацией в цикле по файловому объекту. Это может понадобиться, если нам требуется провести какие-то преобразования в каждой строке, но нужно прекратить их по окончании файла.

Пример – IDE

with open('war_and_peace.  txt', 'r', encoding='utf8') as file:
    for line in file:
        print(line[:15].lower())

Результат выполнения

— eh bien, mon
так говорила в 
«si vous n'avez
— dieu, quelle 
он говорил на т
— avant tout di
— как можно быт
— а праздник ан
— я думала, что
— ежели бы знал
— ne me tourmen
— как вам сказа
князь василий г
быть энтузиастк

В примере выше мы прошлись по всем строкам текста и вывели на печать первые 15 символов каждой строки в нижнем регистре.

4. Запись в файл

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

Пример – Интерактивный режим

>>> with open('even. txt', 'w', encoding='utf8') as file:
           for num in range(2, 20, 2):
                file.write(str(num))

В результате появится текстовый файл с четными числами. Но записаны они очень неудобно – в одну строку без пробелов: 24681012141618. Чтобы исправить положение, помимо записи самой строки требуется внести еще и символ окончания строки

Пример – Интерактивный режим

>>> with open('even.txt', 'w', encoding='utf8') as file:
           for num in range(2, 20, 2):
                file.write(str(num) + '\n')

Вот теперь файл выглядит так, как мы запланировали.

Такой способ, конечно, не всегда удобен. Некоторые предпочитают пользоваться другим вариантом записи текста в файл – через привычную функцию print().
Повторим задачу с ее использованием.

Пример – Интерактивный режим

>>> with open('even.  txt', 'w', encoding='utf8') as file:
           for num in range(2, 20, 2):
                print(num, file=file)

По умолчанию функция print() выводит информацию (в большинстве случаев текстовую) в поток STDOUT на устройство отображения (монитор). В нашем случае мы его перенаправляем на файловый объект(поток) file.

Используя методику записи в файл нужно понимать, что если файла нет – то он создается, если же он есть, то все его содержимое удаляется и перезаписывается. А, вдруг, вы забыли переименовать документ и случайно переписали его содержимое? Мало приятного.
Избежать такой беды можно использованием режима x.

Пример – Интерактивный режим

>>> with open('even.txt', 'x', encoding='utf8') as file:
           for num in range(2, 20, 2):
                print(num, file=file)

При исполнении кода возникнет ошибка FileExistsError, говорящая о том, что такой файл уже имеется на диске. Поэтому либо создавайте документ с другим наименованием, либо удаляйте старый.

5. Дозапись в файл

Не всегда требуется записывать в файл единоразово. Во многих ситуациях нужно дополнять имеющийся документ новым контентом (при парсинге, логировании и т.п.). На помощь приходит режим a.

Так как выше мы уже имеем файл с четными числами до 18, дополним его четными числами до 100 включительно.

Пример – Интерактивный режим

>>> with open('even.txt', 'x', encoding='utf8') as file:
           for num in range(2, 20, 2):
                print(num, file=file)

В документе even.txt теперь имеются все четные числа от 2 до 100.

В статье приведены базовые основы работы с файлами Python на примере функции open(). Она намного сложнее, имеет дополнительные режимы, позволяет взаимодействовать не только с текстовыми документами формата txt, но и любыми другими типами данных (картинками, медиафайлами, excel-таблицами, html-страницами и т. д.).

15 ОКТЯБРЯ / 2020

Как вам материал?

Читайте также

Работа с текстовыми файлами Python 3

2023-01-26

Независимо от того, какое приложение вы используете, гарантировано, что в процессе его работы будет задействован ввод или вывод данных. В этом руководстве кратко описываются форматы, которые может обрабатывать Python. Затем мы рассмотрим, как открывать, считывать и записать текстовый файл в Python 3.

• Работа с текстовыми файлами Python 3 -исходные ресурсы
• Основа
• Шаг 1 — Создание текстового файла
• Шаг 2 — Открытие файла
• Шаг 3 — Чтение файла
• Шаг 4 — Запись файла
• Шаг 5 — Закрытие файла
• Шаг 6 — Проверка кода
• Заключение

Для этого руководства нужно установить Python 3. Также на вашем компьютере должна быть установлена локальная среда программирования.

Python может с относительной легкостью обрабатывать различные форматы файлов:

В этой статье основное внимание будет уделено формату txt.

Сначала нужно подготовить файл для работы. Для этого мы откроем любой текстовый редактор для python и создадим новый txt-файл, назовем его days. txt.
В этом файле необходимо ввести несколько строк. В приведенном ниже примере мы перечислим дни недели:

days.txt

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

Затем сохраните файл. В нашем примере пользователь sammy сохранил файл здесь: /users/sammy/days.txt. Это будет важно на последующих этапах, когда откроем файл в Python.

Прежде чем написать программу, нужно создать файл для кода Python. С помощью текстового редактора создадим файл files.py. Чтобы упростить задачу, сохраните его в том же каталоге, что и файл days.txt:

/users/sammy/.

Чтобы открыть файл, сначала нужно каким-то образом связать его с переменной в Python. Этот процесс называется открытием файла. Сначала мы укажем Python, где находится файл.

Чтобы Python мог открыть файл, ему требуется путь к нему: days.txt -/users/sammy/days.txt. Затем создаем строковую переменную для хранения этой информации. В нашем скрипте files.py мы создадим переменную path и установим для нее значение days. txt.

files.py

path = '/users/sammy/days.txt'

Затем используем функцию Python open(), чтобы открыть файл days.txt. В качестве первого аргумента она принимает путь к файлу.

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

Вот некоторые из существующих режимов:

• ‘r’: использовать для чтения;
• ‘w’: использовать для записи;
• ‘x’: использование для создания и записи в новый файл;
• ‘a’: использование для добавления к файлу;
• ‘r +’: использовать для чтения и записи в тот же файл.

В текущем примере нужно только считать данные из файла, поэтому будем использовать режим «r». Применим функцию open(), чтобы открыть файл days.txt и назначить его переменной days_file.

files.py

days_file = open(path,'r')

После открытия файла мы сможем прочитать его, что сделаем на следующем шаге.

Файл был открыт, и мы можем работать с ним через переменную, которую мы ему присвоили. Python предоставляет три связанные операции для чтения информации из файла. Покажем, как использовать каждую из них.

Первая операция <file>.read() возвращает все содержимое файла как одну строку.

days_file.read()
Вывод
'MondaynTuesdaynWednesdaynThursdaynFridaynSaturdaynSundayn'

Вторая операция <file>.readline() возвращает следующую строку файла (текст до следующего символа новой строки, включая сам символ). Проще говоря, эта операция считывает файл по частям.

days_file.readline()
Вывод
'Mondayn'

Поэтому, когда вы прочтете строку с помощью readline, она перейдет к следующей строке. Если вы снова вызовете эту операцию, она вернет следующую строку, прочитанную в файле.

days_file.readline()
Вывод
'Tuesdayn'

Последняя операция, <file>.readlines(), возвращает список строк в файле. При этом каждый элемент списка представляет собой одну строку.

days_file.readlines()
Вывод
['Mondayn', 'Tuesdayn', 'Wednesdayn', 'Thursdayn', 'Fridayn', 'Saturdayn', 'Sundayn']

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

На этом этапе мы запишем новый файл, который включает в себя название «Days of the Week», и дни недели. Сначала создадим переменную title.

files.py

title = 'Days of the Weekn'

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

files.py

path = '/users/sammy/days.txt'
days_file = open(path,'r')
days = days_file.read()

Теперь, когда у нас есть переменные для названия и дней недели, запишем их в новый файл. Сначала нужно указать расположение файла. Мы будем использовать каталог /users/sammy/. Также нужно указать новый файл, который мы хотим создать. Фактический путь будет /users/sammy/new_days.txt. Мы записываем его в переменную new_path. Затем открываем новый файл в режиме записи, используя функцию open() с режимом w.

files.py

new_path = '/users/sammy/new_days.txt'
new_days = open(new_path,'w')

Если файл new_days.txt уже существовал до открытия, его содержимое будет удалено, поэтому будьте осторожны при использовании режима «w».

Когда новый файл будет открыт, поместим в него данные, используя <file>.write(). Операция write принимает один параметр, который должен быть строкой, и записывает эту строку в файл.

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

iles.py

new_days.write(title)
print(title)
new_days.write(days)
print(days)

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

Закрытие файла деактивирует соединение между файлом, сохраненным на жестком диске, и файловой переменной. Закрытие файлов также гарантирует, что другие программы смогут получить к ним доступ и безопасно сохранить данные. Закроем все наши файлы, используя функцию <file>.close().

files.py

days_file.close()
new_days.close()

Мы закончили обработку файлов в Python и можем перейти к просмотру кода.

Конечный результат должен выглядеть примерно так:

files.py

path = '/users/sammy/days.txt'
days_file = open(path,'r')
days = days_file.read()
new_path = '/users/sammy/new_days.txt'
new_days = open(new_path,'w')
title = 'Days of the Weekn'
new_days.write(title)
print(title)
new_days.write(days)
print(days)
days_file.close()
new_days.close()

После сохранения кода откройте терминал и запустите свой Python- скрипт, например:
python files.py

Результат должен выглядеть так:

Вывод
Days of the Week
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

Теперь проверим код полностью, открыв файл new_days. txt. Если все пройдет хорошо, когда мы откроем этот файл, его содержимое должно выглядеть следующим образом:

new_days.txt

Days of the Week
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

В этой статье мы рассказали, как работать с простыми текстовыми файлами в Python 3. Теперь вы сможете открывать, считывать, записывать и закрывать файлы в Python.

Пожалуйста, оставляйте ваши отзывы по текущей теме статьи. За комментарии, отклики, дизлайки, лайки, подписки низкий вам поклон!

Вадим Дворниковавтор-переводчик статьи «How To Handle Plain Text Files in Python 3»

Глава 8. Работа с файлами — Документация по Python 101 1.0

В этой главе рассказывается о чтении и записи данных в файлы на жестком диске. Вы обнаружите, что чтение и запись файлов в Python очень просты. Давайте начнем!

Как читать файл

Python имеет встроенную функцию open , которую мы можем использовать, чтобы открыть файл для чтения. Создайте текстовый файл с именем «test. txt» со следующим содержимым:

 Это тестовый файл.
строка 2
строка 3
эта строка намеренно оставлена ​​пустой
 

Вот несколько примеров, которые показывают, как использовать open для чтения:

 handle = open("test.txt")
handle = open(r"C:\Users\mike\py101book\data\test.txt", "r")
 

Первый пример открывает файл с именем test.txt в режиме только для чтения. Это режим по умолчанию функции open . Обратите внимание, что мы не передали полный путь к файлу, который хотели открыть в первом примере. Python будет автоматически искать в папке, в которой запущен скрипт, test.txt . Если он не найдет его, вы получите IOError.

Во втором примере показан полный путь к файлу, но вы заметите, что он начинается с «r». Это означает, что мы хотим, чтобы Python обрабатывал строку как необработанную строку. Давайте рассмотрим разницу между указанием исходной строки и обычной строки:

 >>> print("C:\Users\mike\py101book\data\test. txt")
C:\Пользователи\Майк\py101book\данные est.txt
>>> print(r"C:\Users\mike\py101book\data\test.txt")
C:\Пользователи\Майк\py101book\data\test.txt
 

Как видите, когда мы не указываем его как необработанную строку, мы получаем недопустимый путь. Почему это происходит? Ну, как вы, возможно, помните из главы о строках, существуют определенные специальные символы, которые необходимо экранировать, например «n» или «t». В этом случае мы видим, что есть «t» (то есть табуляция), поэтому строка послушно добавляет табуляцию к нашему пути и портит его для нас.

Второй аргумент во втором примере также является «r». Это сообщает open , что мы хотим открыть файл в режиме только для чтения. Другими словами, он делает то же самое, что и первый пример, но более явно. Теперь давайте на самом деле прочитаем файл!

Поместите следующие строки в сценарий Python и сохраните его в том же месте, что и файл test.txt:

 handle = open("test.txt", "r")
данные = дескриптор. чтение()
печать (данные)
ручка.закрыть()
 

Если вы запустите это, он откроет файл и прочитает весь файл как строку в переменную данных . Затем мы печатаем эти данные и закрываем дескриптор файла. Вы всегда должны закрывать дескриптор файла, поскольку вы никогда не знаете, когда другая программа захочет получить к нему доступ. Закрытие файла также поможет сэкономить память и предотвратить странные ошибки в ваших программах. Вы можете указать Python просто читать строку за раз, читать все строки в список Python или читать файл по частям. Последний вариант очень удобен, когда вы имеете дело с действительно большими файлами и не хотите читать их целиком, что может привести к переполнению памяти ПК.

Давайте рассмотрим различные способы чтения файлов.

 дескриптор = открыть ("test.txt", "r")
data = handle.readline() # прочитать только одну строку
печать (данные)
ручка.закрыть()
 

Если вы запустите этот пример, он прочитает только первую строку вашего текстового файла и распечатает ее. Это не слишком полезно, поэтому давайте попробуем метод readlines() дескриптора файла:

 handle = open("test.txt", "r")
data = handle.readlines() # прочитать ВСЕ строки!
печать (данные)
ручка.закрыть()
 

После запуска этого кода вы увидите список Python, напечатанный на экране, потому что это то, что возвращает метод readlines : список! Давайте на минутку научимся читать файл небольшими порциями.

Как читать файлы по частям

Самый простой способ прочитать файл по частям — использовать цикл. Сначала мы научимся читать файл построчно, а затем научимся читать его по килобайтам за раз. Мы будем использовать цикл для для нашего первого примера:

 дескриптор = открыть ("test.txt", "r")
для строки в ручке:
    печать (строка)
ручка.закрыть()
 

Здесь мы открываем дескриптор файла только для чтения, а затем используем цикл for для его итерации. Вы обнаружите, что можете перебирать все виды объектов в Python (строки, списки, кортежи, ключи в словаре и т. д.). Это было довольно просто, верно? Теперь давайте делать это по частям!

 дескриптор = открыть ("test.txt", "r")
пока верно:
    данные = дескриптор.чтение(1024)
    печать (данные)
    если не данные:
        перерыв
 

В этом примере мы используем цикл Python while для чтения по килобайту файла за раз. Как вы, наверное, знаете, килобайт — это 1024 байта или символа. Теперь давайте представим, что мы хотим прочитать двоичный файл, например PDF.

Как читать двоичный файл

Читать двоичный файл очень просто. Все, что вам нужно сделать, это изменить режим файла:

 handle = open("test.pdf", "rb")
 

Итак, на этот раз мы изменили режим файла на rb , что означает чтение-бинарное . Вы обнаружите, что вам может понадобиться читать двоичные файлы, когда вы загружаете PDF-файлы из Интернета или переносите файлы с ПК на ПК.

Запись файлов в Python

Если вы следили за этим, вы, вероятно, догадались, какой флаг режима файла используется для записи файлов: «w» и «wb» для режима записи и режима записи в двоичном виде. Давайте рассмотрим простой пример, хорошо?

ВНИМАНИЕ : При использовании режимов «w» или «wb», если файл уже существует, он будет перезаписан без предупреждения! Вы можете проверить, существует ли файл, прежде чем открывать его, используя Python 9.Модуль 0007 ОС . См. раздел os.path.exists в , глава 16 .

 дескриптор = открыть ("test.txt", "w")
handle.write("Это тест!")
ручка.закрыть()
 

Это было просто! Все, что мы здесь сделали, это изменили режим файла на «w» и вызвали метод дескриптора файла write , чтобы записать некоторый текст в файл. Дескриптор файла также имеет метод writelines , который принимает список строк, которые дескриптор затем записывает на диск по порядку.

Использование with Operator

В Python есть небольшая встроенная функция with , которую можно использовать для упрощения чтения и записи файлов. Оператор с создает в Python то, что известно как менеджер контекста , который автоматически закроет файл, когда вы закончите его обработку. Давайте посмотрим, как это работает:

 с open("test.txt") в качестве file_handler:
    для строки в file_handler:
        печать (строка)
 

Синтаксис для с оператором немного странный, но вы довольно быстро разберетесь. По сути, мы заменяем:

 handle = open("test.txt")
 

с этим:

 с open("test.txt") как file_handler:
 

Вы можете выполнять все обычные операции файлового ввода-вывода, которые обычно выполняете, пока находитесь в кодовом блоке с . Как только вы покинете этот блок кода, дескриптор файла закроется, и вы больше не сможете его использовать. Да, Вы прочли это правильно. Вам больше не нужно явно закрывать дескриптор файла, поскольку с оператором делает это автоматически! Посмотрите, сможете ли вы изменить некоторые из предыдущих примеров из этой главы, чтобы они также использовали метод с .

Обнаружение ошибок

Иногда при работе с файлами случаются неприятные вещи. Файл заблокирован, потому что его использует какой-то другой процесс или у вас есть какая-то ошибка разрешения. Когда это произойдет, вероятно, произойдет ошибка IOError . В этом разделе мы рассмотрим, как отлавливать ошибки обычным способом и как их отлавливать с помощью с оператором . Подсказка: идея в основном одинакова в обоих!

 попробуйте:
    file_handler = открыть ("test.txt")
    для строки в file_handler:
        печать (строка)
кроме IOError:
    print("Произошла ошибка ввода-вывода!")
окончательно:
    file_handler.close()
 

В приведенном выше примере мы заключаем обычный код в конструкцию try/except . При возникновении ошибки мы выводим сообщение на экран. Обратите внимание, что мы также закрываем файл, используя finally 9Заявление 0008. Теперь мы готовы посмотреть, как бы мы сделали то же самое, используя с :

 попробуйте:
    с open("test.txt") как file_handler:
        для строки в file_handler:
            печать (строка)
кроме IOError:
    print("Произошла ошибка ввода-вывода!")
 

Как вы могли догадаться, мы просто завернули блок в блок так же, как и в предыдущем примере. Разница здесь в том, что нам не нужен оператор finally , так как менеджер контекста обрабатывает его за нас.

Подведение итогов

К этому моменту вы должны уже хорошо разбираться в работе с файлами в Python. Теперь вы знаете, как читать и записывать файлы, используя старый стиль и новый стиль со стилем . Вы, скорее всего, увидите оба стиля в дикой природе. В следующей главе мы узнаем, как импортировать другие модули, поставляемые с Python. Это позволит нам создавать программы, используя готовые модули. Давайте начнем!

Понимание работы с файлами в Python с примерами — SitePoint

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

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

Содержание:

1. Обработка файлов в Python: файлы и пути к файлам
   • Использование модуля pathlib
   • Как получить текущий рабочий каталог
   • Абсолютные и относительные пути
   • Как создать каталог в Python
   • Как изменить текущий рабочий каталог
   • Как удалить файлы или каталоги в Python
   • Как составить список файлов и каталогов в Python
2. Обработка файлов в Python: чтение и запись данных
   • Как открыть файл в Python
   • Как закрыть файл в Python
   • С выпиской
   • Как прочитать файл в Python
   • Как записать файл в Python

Обработка файлов в Python: файлы и пути к файлам

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

Использование модуля pathlib

Python предоставляет модуль pathlib для выполнения таких операций, как навигация по каталогам и файлам, создание папок, определение путей к файлам и т. д. Модуль pathlib стал доступен в Python 3.4 и обеспечивает объектно-ориентированный подход к программированию для обработки путей файловой системы.

Модуль pathlib имеет Path класс для навигации по путям файловой системы. Вы импортируете его в свою программу следующим образом:

 из pathlib import Path
 

Как получить текущий рабочий каталог

Вы можете получить текущий рабочий каталог («cwd») в Python, используя метод cwd() объекта Path . Этот метод возвращает путь к каталогу, в котором мы сейчас работаем, в виде строки, как показано во фрагменте кода ниже:

 из pathlib import Path
р = Путь. cwd()
печать (р)
 

Вот вывод этого кода:

 /home/ini/Dev/Tutorial/sitepoint
 

Абсолютные и относительные пути

Пути к файлам можно указать двумя способами: либо их абсолютный путь, либо их относительный путь. Оба пути указывают на текущее местоположение файла.

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

 /home/ini/Dev/Tutorial/sitepoint/filehandling.py
 

Корневая папка (как показано в приведенном выше коде) — это домашняя папка в ОС Linux.

Относительный путь файла объявляет его путь относительно текущего рабочего каталога. Давайте посмотрим на пример:

 ./sitepoint/filehandling.py
 

Приведенный выше код показывает относительный путь к файлу Python filehandling.py .

Как создать каталог в Python

Класс Path имеет метод mkdir() для создания новых папок или каталогов в Python. Метод mkdir() принимает три аргумента: режим , родители и exists_ok .

Для родителей и exists_ok по умолчанию установлено значение False . Если задано значение False , аргумент parents выдает исключение FileNotFoundError , если родитель по указанному пути не существует. exists_ok выдает FileExistsError по умолчанию, если целевой каталог уже существует.

Вот пример:

 из pathlib import Path
path = '/home/ini/Dev/Tutorial/sitepoint/projects'
р = путь (путь)
p.mkdir()
 

В приведенном выше примере у нас есть переменная path , задающая расположение для нового каталога. Объект Path p был создан со строковым аргументом пути, и метод mkdir() вызывается для p . Если мы сейчас проверим папку sitepoint , мы найдем только что созданный 9Папка 0227 проектов .

Как изменить текущий рабочий каталог

Модуль pathlib не поддерживает смену каталогов. Если мы хотим сделать это, мы должны использовать модуль ОС — еще один встроенный модуль для взаимодействия с операционной системой нашего компьютера.

Чтобы использовать модуль ОС, мы импортируем его в нашу программу, как показано ниже:

 import os
 

Для переключения между каталогами используйте метод chdir() модуля ОС. Новый путь передается в качестве аргумента методу для перехода из текущего рабочего каталога в другой.

После создания новой папки в предыдущем примере кода мы можем изменить каталог на папку проектов :

 import os
os.chdir('/home/ini/Dev/Tutorial/sitepoint/projects')
 

Чтобы подтвердить изменение каталога, используйте метод cwd() объекта Path , который возвращает строку текущего рабочего каталога: /home/ini/Dev/Tutorial/sitepoint/projects .

Как удалить файлы или каталоги в Python

Мы можем удалять файлы и каталоги в Python, используя методы unlink() объекта Path и rmdir() соответственно.

Чтобы удалить файлы в Python, создайте экземпляр объекта Path файла и примените метод unlink() . (При удалении файлов программа выдаст исключение FileNotFoundError , если файл не существует.)

Рассмотрим пример кода:

 из pathlib import Path
path = '/home/ini/Dev/Tutorial/sitepoint/file_handling.txt'
р = путь (путь)
p.unlink ()
 

Файл file_handling.txt удален из каталога sitepoint . Если мы попытаемся удалить файл снова, мы получим исключение FileNotFoundError .

Чтобы удалить или удалить каталог, примените метод rmdir() к удаляемому объекту Path , например:

 from pathlib import Path
path = '/home/ini/Dev/Tutorial/projects'
р = путь (путь)
p. rmdir()
 

Папка проектов удалена из Папка Tutorial .

Как составить список файлов и каталогов в Python

Чтобы получить обзор всего содержимого каталога, используйте метод iterdir() для объекта Path файла. Этот метод возвращает объект генератора. Теперь мы можем перебрать объект генератора, чтобы получить все существующие файлы и каталоги в этой конкретной папке:

 из pathlib import Path
path = '/home/ini/Dev/Tutorial/sitepoint'
р = путь (путь)
для файла в p.itrdir():
    распечатать файл)
 

Вот результат кода выше:

 /home/ini/Dev/Tutorial/sitepoint/array.py
/home/ini/Dev/Tutorial/sitepoint/unittesting.py
/home/ini/Dev/Учебник/sitepoint/код
/home/ini/Dev/Tutorial/sitepoint/search_replace.py
/home/ini/Dev/Tutorial/sitepoint/__pycache__
/home/ini/Dev/Tutorial/sitepoint/pangram.txt
/home/ini/Dev/Tutorial/sitepoint/random.txt
/home/ini/Dev/Учебник/sitepoint/.pytest_cache
/home/ini/Dev/Tutorial/sitepoint/exception. py
/home/ini/Dev/Tutorial/sitepoint/files.py
/home/ini/Dev/Tutorial/sitepoint/regex.py
/home/ini/Dev/Tutorial/sitepoint/filehandling.py
 

Работа с файлами в Python: чтение и запись данных

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

• r : открывает файл для чтения. Режим чтения выдает ошибку, когда файл не существует.

• r+ : открывает файл для чтения и записи данных в файловый объект. Выдается ошибка, если файл не существует.

• w : в этом режиме открывается файл для записи данных. Режим записи переопределяет существующие данные и создает новый файловый объект, если он не существует.

• w+ : открывает файл для чтения и записи данных. Существующие данные в файле переопределяются при открытии в этом режиме.

• a : режим добавления добавляет к файлу, если файл существует. Он также создает новый файл, если существующего файла нет. Он не отменяет существующие данные.

• a+ : этот режим открывает файл для добавления и чтения данных.

• x : режим создания используется для создания файлов в Python. Выдается ошибка, если файл существует.

Добавление b к любому из режимов доступа изменяет его текстовый формат по умолчанию на двоичный формат (например, rb , rb+ , wb и т. д.).

Как открыть файл в Python

Чтобы открыть файл в Python, мы можем использовать функцию open() . Он принимает как минимум два аргумента — имя файла и описание режима — и возвращает файловый объект. По умолчанию файл открывается для чтения в текстовом режиме, но мы можем указать, хотим ли мы вместо этого двоичный режим.

Вот простой код для открытия файла:

 f = open(file, mode='r', encoding=None)
 

После этого шага, как показано в приведенном выше коде, мы можем начать операции чтения-записи над файловым объектом. По умолчанию файлы всегда обрабатываются в текстовом режиме. Метод open() принимает как минимум два аргумента: путь к файлу и режим.

Как закрыть файл в Python

После открытия файлового объекта и выполнения операций по обработке файла нам необходимо закрыть файл. Часто это последний шаг в чтении или записи файлов в Python. Метод объекта файла close() используется для закрытия ранее открытых файлов.

Закрытие файлов в Python выглядит так:

 f = open('filename', 'mode', encoding=None)
// файловые операции, чтение, запись или добавление
е.закрыть()
 

Оператор with

Стандартной практикой является закрытие файлов после их открытия и выполнения файловых операций. Некоторые файлы можно забыть закрыть после того, как они были открыты.

Оператор with автоматически закрывает файлы после завершения последней операции обработки файлов в своей области. Например:

 с open('random.txt', 'r', encoding='UTF-8') как f:
    печать (f.read())
 

Вот вывод кода выше:

 Привет, мир!
Привет, мир!
 

Как видно из фрагмента кода выше, оператор with неявно закрывает файл после оператора print . (Мы будем использовать оператор с оператором в оставшейся части этого руководства.)

Как прочитать файл в Python

Есть несколько способов прочитать данные из файла в Python. Мы можем прочитать содержимое файла, используя read() , readline() и readlines() 9.0228 методы.

Метод read()

Метод read() возвращает строку всех символов читаемого файла. Указатель помещается в начало содержимого файла. Режим по умолчанию — чтение с начала файла до конца, за исключением случаев, когда указано количество символов.

Взгляните на фрагмент кода ниже:

 с open('random.txt', 'r', encoding='UTF-8') как f:
    печать (f.read())
 

Вот результат этого кода:

 Это случайный текст.
Вот вторая строчка.
Небо голубое.
Розы красные.
 

Мы можем указать, сколько символов читать из текстового файла. Просто передайте количество символов в качестве аргумента методу read() :

 с open('random.txt', 'r', encoding='UTF-8') как f:
    печать (f.read (12))
 

Вот вывод этого кода:

 Это немного
 

Как видно из приведенного выше примера, интерпретатор считывает только 12 символов из всего файла.

Метод readline()

Этот метод считывает из файла по одной строке за раз. Он читает с начала файла и останавливается там, где встречается символ новой строки. См. пример кода ниже:

 с open('random.txt', 'r', encoding='UTF-8') как f:
    печать (f.readline())
 

Приведенный выше код выводит следующее:

 Это случайный текст. 
 

Метод readlines()

Этот метод возвращает список всех строк из существующего читаемого файла. См. фрагмент кода ниже:

 с open('random.txt', 'r', encoding='UTF-8') как f:
    печать (f.readlines())
 

Вот результат:

 ['Это какой-то случайный текст.\n', 'Вот вторая строка.\n', 'Небо голубое.\n', 'Розы красные.']
 

Примечание: все методы чтения файлового потока возвращают пустое значение при достижении конца файла. Метод seek() возвращает файловый курсор в начало файла.

Как записать в файл в Python

Метод write() в Python полезен при попытке записать данные в файл. Для записи в открытый файл необходимо установить один из следующих режимов доступа: w , w+ , a , a+ и т. д. Опять же, по умолчанию используется текстовый режим, а не двоичный.

Метод

 с open('random.txt', 'w', encoding='UTF-8') как f:
    f.write("Привет, мир!")
 

 Hello, World!
 

 words = ['Небо голубое.\n', 'Розы красные.']
с open('random.txt', 'w', encoding='UTF-8') как f:
    f.writelines(слова)
 

 Небо голубое.
Розы красные.