Запись файлов
Писать в файлы позволяет та же функция open() , которую мы использовали на прошлом занятии, однако теперь укажем дополнительный аргумент «w» — write:
Напомним, что следует следить за отступами и писать в файл после выхода из блока with уже нельзя:
Если в файл хочется записать одну большую строку с множеством переносом строк, а ставить много \n не хочется, то можно воспользоваться тройными кавычками, которые позволяют задавать “многострочные” строки и свободно использовать внутри них одинарные и двойные кавычки:
Следует отметить, что во всех предыдущих примерах, если файла с таким именем не существовало, то он создавался, а если существовал, то он переписывался. Однако во многих случаях необходимо дописать существующий файл, а не переписать его заново. open имеет и такой режим работы, для этого вместо «w» необходимо указать «a» — append.
Чтение файлов построчно
Иногда бывает такое, что файлы очень большие и прочитать их целиком совсем никак не получается. Что, если вам нужно прочитать файл на 16 миллиардов строк, который весит десятки терабайт?
Да что там 16 миллиардов. Студенты порой жалуются, что на экзамене файл весит 50МБ и их программы долго его читают. Это не от того, что файл большой. Просто читают неправильно.
Какое здесь может быть решение? Очевидно, надо читать построчно. Но как?
У объекта, который возвращает функция open() есть много методов. В том числе метод .readlines() . По названию понятно, что делает этот метод — читает строки. Однако, в нашей задаче этот метод никак не поможет. Разберемся почему:
Как мы видим, метод readlines() создает список строк всего файла. То есть тоже читает файл целиком.
Как же правильно прочитать построчно?
При таком способе чтения python не будет считывать файл целиком, а будет считать построчно. То есть при чтении какого-угодно файла одновременно мы будем читать только одну строку. И 16 терабайт пройдут незаметно.
Домашнее задание
Для каждого варианта своё задание.
Программа должна спрашивать у пользователя слова до тех пор, пока он не введёт пустое слово. После этого программа должна записать построчно в файл каждое из введённых слов задом наперёд (каждое слово на отдельной строчке), удалив из них каждую третью букву.
Программа должна спрашивать у пользователя слова до тех пор, пока он не введёт пустое слово. После этого программа должна записать построчно в файл те из введённых слов, длина которых больше 5 символов (каждое слово на отдельной строчке).
Программа должна спрашивать у пользователя слова до тех пор, пока он не введёт пустое слово. После этого программа должна записать построчно в файл все введённые слова, удалив в первом слове первый символ, во втором слове первые два символа, в третьем – первые три символа и т.д. (каждое слово на отдельной строчке).
Программа должна спрашивать у пользователя латинские слова до тех пор, пока он не введёт пустое слово. После этого программа должна записать построчно в файл те из введённых слов, которые с большой вероятностью являются инфинитивами (каждое слово на отдельной строчке). [Словами типа esse можно не заморачиваться, но пассивный инфинитив надо учесть.]
Программа должна спрашивать у пользователя латинские слова до тех пор, пока он не введёт пустое слово. После этого программа должна записать построчно в файл те из введённых слов, которые с большой вероятностью являются формой 3-го лица пассива настоящего времени (каждое слово на отдельной строчке). [Нерегулярными словами можно не заморачиваться.]
Программа должна получить от пользователя подряд 7 чисел, а после этого записать в файл 7 строчек, состоящих из соответствующего числа букв X (на первой строчке количество иксов равно первому введённому числу, на второй – второму и т. д.; если введённое число отрицательно, иксов на этой строчке быть не должно). В задаче обязательно пользоваться списком, а не 7 переменными!
Программа должна получить от пользователя подряд 8 слов, а после этого записать в файл 4 строчки с попарными склейками этих слов: на 1-й строчке – склеенные слова 1 и 2, на второй – 3 и 4 и т. д. В задаче обязательно пользоваться списком, а не 8 переменными!
10 самых продуктивных техник для работы с файлами в Python
Какой бы проект вы ни разрабатывали, вам не избежать работы с файлами либо на компьютере, либо на сервере. И неудивительно, поскольку они являются самыми распространёнными контейнерами для хранения взаимосвязанной и обычно структурированной информации. При этом многим приходится выискивать конкретные операции, связанные с обработкой файлов. Поэтому мы решили посвятить данную статью 10 наиболее эффективным техникам для работы с файлами в Python.
1. Показ текущей директории
Чтобы узнать текущую рабочую директорию, мы можем просто ввести функцию getcwd() модуля os, как показано ниже:
Данный код также демонстрирует возможность использования модуля pathlib для получения текущей рабочей директории. Обратите внимание, что для выполнения операций с файлами именно этот модуль является предпочтительным вариантом, и в статье вас ждёт немало примеров его употребления. Однако, если у вас устаревшая версия Python (< 3.4), то вам придётся использовать модуль os .
2. Создание новой директории
Для создания новой директории можно применить функцию mkdir() , которая выполнит эту операцию по конкретно заданному пути. Если вы просто укажете имя новой директории, то она будет создана в текущем каталоге:
Однако, если вы намерены создать новую директорию с несколькими вложенными уровнями (имеется в виду наличие одной папки внутри другой), то вам необходимо использовать функцию makedirs() . Обратимся к простому примеру:
Если же у вас последние версии Python (≥ 3.4), то для решения вышеуказанной задачи можно воспользоваться преимуществом модуля pathlib . При этом он способен не только создавать поддиректории, но также при необходимости работать с каталогами, отсутствующими в пути. Рассмотрим пример:
Имейте в виду, что попытка повторного выполнения вышеприведённого кода может вызвать проблемы — вы не сможете создать новую директорию, если такая уже существует. Стоит отметить, что эта проблема решается путём присвоения аргументу exist_ok значения True , как показано выше. А вот значение False , установленное для него по умолчанию, не позволит повторно создать уже существующую директорию и приведёт к ошибке.
3. Удаление директорий и файлов
По завершении операций с файлами или папками, возможно, потребуется их удалить, чтобы упорядочить ресурсы компьютера. Для удаления файла в модуле os применяется функция remove() , а для удаления папки — функция rmdir() . Попытка же удалить директорию с помощью remove() вызовет ошибку. Рассмотрим применение этих функций:
При использовании модуля pathlib за удаление файла отвечает метод unlink() , а за удаление директории — rmdir() . Обратите внимание, что они оба являются методами экземпляра объекта Path .
4. Получение списка файлов
В процессе обработки данных для аналитики или проектов МО вам потребуется получить список файлов в определённой директории. Зачастую их имена соответствуют определённому шаблону. Допустим, мы хотим найти все файлы .txt в директории. Далее рассмотрим, как это можно сделать с помощью метода glob() с объектом Path . Обратите внимание, что данный метод создаёт генератор с возможностью итерации. Следующий код наглядно демонстрирует создание генератором списка путей файлов:
Как вариант, также удобно использовать модуль glob напрямую, как показано ниже. Он располагает аналогичной функциональностью, создавая списки имён файлов, с которыми впоследствии можно работать. Заметьте, что Path.glob() создаёт пути. Оба метода будут работать в большинстве сценариев, таких как чтение и запись файлов.
5. Перемещение и копирование файлов
Перемещение и копирование — одна из стандартных задач управления файлами, которая довольно легко решается в Python. Для перемещения вы просто переименовываете файл, заменяя его старую директорию целевой. Предположим, необходимо переместить все файлы .txt в другую папку. В следующем примере кода мы увидим, как это можно сделать с помощью модуля pathlib:
Копирование же можно выполнить при помощи функциональности, доступной в shutil, ещё одном полезном модуле из стандартной библиотеки для операций с файлами. Здесь за это отвечает функция copy() , в которой исходный и целевой файлы указываются в виде строк. Ниже вы увидите простой пример. Конечно, вы можете объединить функции copy() и glob() для работы с группой файлов, соответствующих одному паттерну.
6. Проверка директории/файла
На самом деле, эта операция уже много раз встречалась в вышеприведённых примерах. В них для проверки того, существует ли конкретный путь, применялся метод exists() . При условии положительного ответа он возвращает True , в противном случае — False . Примечательно, что эта функция доступна в обоих модулях, os и pathlib, но с разными сигнатурами. Рассмотрим соответствующие примеры их применения:
В модуле pathlib можно также проверить, является ли путь директорией или файлом с готовыми к вызову функциями. Обратимся к следующему примеру:
7. Получение информации о файле
При работе с файлами во многих сценариях возникает необходимость извлечения их имён. С объектом Path это просто как дважды два, и вы уже были свидетелями его применения. Можно просто извлечь атрибут name файлового объекта Path . Если же вам нужно узнать только имя без расширения, то извлекать следует атрибут stem . Следующий фрагмент кода демонстрирует соответствующие случаи применения:
В отдельных случаях вам потребуется узнать расширение файла, с которым вы работаете. Чаще всего можно воспользоваться атрибутом suffix файлового объекта Path , как показано ниже:
Если необходимо получить больше информации о файле, например, его размер и время изменения, то для этого в нашем распоряжении есть метод stat() , принцип действия которого аналогичен os.stat() , знакомого тем, кто привык работать с модулем os.
8. Чтение файлов
Одна из важнейших операций с файлами — считывание их данных. В конце концов, содержимое файла является, вероятно, единственной причиной его появления. Самый традиционный способ состоит в создании файлового объекта с помощью встроенной функции open() . По умолчанию она откроет файл в режиме чтения и будет работать с его данными как с текстом. Рассмотрим пример:
Этот код демонстрирует самые распространённые способы чтения содержимого. Если вы знаете, что ваш файл включает немного данных, можете считать их все за раз с помощью метода read() . Но если он очень крупный, то следует рассмотреть вариант с генератором, роль которого выполняет файловый объект. Он обрабатывает данные построчно и тем самым экономно расходует память, обходясь без загрузки всех данных при применении read() .
Как уже ранее упоминалось, функция open() по умолчанию работает с содержимым файла как с текстом. Однако в случае с бинарными файлами необходимо явно задать данное условие. Например, вместо ‘r’ следует ввести ‘rb’ . Это требование также относится и к записи файлов, о чём мы поговорим далее. Ещё один непростой момент связан с кодировкой файла. Во многих случаях функция open() сможет выполнить эту операцию за нас, и большинство файлов, с которыми мы работаем, будут в кодировке “utf-8”. Если же вы обрабатываете файлы, применяя другие форматы кодировки, вам следует установить аргумент encoding .
9. Запись файлов
Для записи данных можно опять же создать файловый объект, открыв файл в режиме записи ( ‘w’ ) или дозаписи ( ‘a’ ). В первом случае при записи данных в файл его старое содержимое удаляется, а во втором — данные добавляются в конец файла. Рассмотрим пример работы этих двух режимов в следующем фрагменте кода.
Этот код подтверждает, что мы можем записывать данные в двух режимах: записи и дозаписи. Обратили вы внимание или нет, но каждый раз при открытии файла использовалась инструкция with . Объясняется это тем, что она создаёт контекст для обработки файла и помогает закрыть файловый объект по завершении операций. Если же вовремя этого не сделать, то открытый файловый объект может повредиться.
10. Архивирование и разархивирование файлов
При работе с большим числом файлов может потребоваться их архивирование для долгосрочного хранения или временной передачи. Соответствующие возможности предоставляются модулем zipfile. Для архивирования файлов функцией ZipFile() создаётся файловый объект zip, что напоминает случай с функцией open() , поскольку обе эти функции предусматривают создание файлового объекта, управляемого контекстным менеджером (вспоминаете применение инструкции with ?). Обратимся к фрагменту кода с простым примером:
Вы можете получить zip-файл из внешнего источника, и вам потребуется извлечь из него файлы. Чтобы не усложнять, допустим, что мы распаковываем их в текущую директорию. Обратите внимание на то, что имена файлов в zip-файле совпадают с содержащимися в директории, вследствие чего последние будут перезаписаны без предупреждения. Поэтому вам следует рассмотреть вариант извлечения содержимого zip-файла в отдельную папку, где такой проблемы перезаписи не возникнет.
Заключение
Итак, в данной статье мы рассмотрели 10 наиболее полезных операций по работе с файлами. Как вы могли убедиться, все они укладываются в несколько строк кода, поэтому не представляют абсолютно никакой сложности. Если вы с ними не знакомы, то надеемся, что эта статья послужит для вас кратким руководством в процессе работы с файлами.
Чтение файлов#
Посмотрим как считывать содержимое файлов, на примере файла r1.txt:
Метод read — считывает весь файл в одну строку.
Пример использования метода read :
При повторном чтении файла в 3 строке, отображается пустая строка. Так происходит из-за того, что при вызове метода read , считывается весь файл. И после того, как файл был считан, курсор остается в конце файла. Управлять положением курсора можно с помощью метода seek .
readline #
Построчно файл можно считать с помощью метода readline :
Но чаще всего проще пройтись по объекту file в цикле, не используя методы read. :
readlines #
Еще один полезный метод — readlines . Он считывает строки файла в список:
Если нужно получить строки файла, но без перевода строки в конце, можно воспользоваться методом split и как разделитель, указать символ \n :
Обратите внимание, что последний элемент списка — пустая строка.
Если перед выполнением split , воспользоваться методом rstrip , список будет без пустой строки в конце:
До сих пор, файл каждый раз приходилось открывать заново, чтобы снова его считать. Так происходит из-за того, что после методов чтения, курсор находится в конце файла. И повторное чтение возвращает пустую строку.
Чтобы ещё раз считать информацию из файла, нужно воспользоваться методом seek , который перемещает курсор в необходимое положение.
Пример открытия файла и считывания содержимого:
Если вызывать ещё раз метод read , возвращается пустая строка:
Но с помощью метода seek можно перейти в начало файла (0 означает начало файла):
После того как с помощью seek курсор был переведен в начало файла, можно опять считывать содержимое:
Построчное чтение файла в Python 3
Вы стали счастливым обладателем больших текстовых файлов, в которых заключены важные данные? Это здорово! Однако, теперь перед Вами стоит задача извлечения данных из файла по частям, желательно, по строкам. Ведь чтение большого файла и одномоментная загрузка его содержимого в оперативную память чревата жалобами компьютера на усталость и «замутненное сознание», что с 2020 года является непозволительной роскошью для рабочих лошадок. Поэтому предлагаю рассмотреть варианты, с помощью которых можно реализовать построчное чтение файла в Python 3 по следующему сценарию:
- Открыть файл
- Считать первую строку
- Вывести на экран первую строку
- Считать вторую строку
- Вывести на экран 2ю строку
- и так далее..
Сразу оговорюсь, что в Python открыть файл и прочитать данные из него можно несколькими способами. Для начала предлагаю взглянуть на наиболее оптимальный (исключительно на мой взгляд) вариант. Детальный разбор кода с рассмотрением других вариантов будет приведен чуть ниже, в следующем разделе статьи.
Оптимальный вариант для построчного чтения файла в Python:
1. Подготавливаем файл:
В качестве примера я буду использовать файл с именем «text.txt», состоящий из 5 строк следующего вида:
Файл «text.txt»
2. Создадим переменную для хранения пути к файлу:
Замените выражение в коде «путь к файлу» на актуальный путь к вашему файлу. Если у вас возникли сложности с определением пути к файлу, ознакомьтесь с инструкцией «Как задать путь к файлу в Python» и возвращайтесь — будем кодить построчное считывание файла!
3. Представленный ниже код откроет файл и выведет его содержимое на экран:
На экран выведется все содержимое файла:
Чтобы дополнить вывод номерами строк, добавим в приведенный выше код переменную num_line для хранения номера строки и функцию enumerate(file) для получения номера строки:
Теперь вывод выглядит так:
Приведенный выше способ вывода данных из файла — не единственный, существуют и другие рабочие варианты. Предлагаю произвести детальный разбор построчного чтения файла в Python для того, чтобы понять как работают используемые функции и ознакомиться с другими вариантами.
Детальный разбор построчного чтения файла в Python:
1. Первым делом мы открываем файл:
Для открытия файла мы использовали функцию open(), которая может принимать несколько аргументов. Однако, наиболее важными аргументами являются первые два:
- путь к файлу;
- режим работы с файлом. Это не обязательный параметр, который по умолчанию принимает значение «r»(read), что позволяет открыть файл для чтения. Давайте взглянем, какие существуют режимы работы с файлами в Python:
- r — (от английского слова read), режим позволяет открыть файл для чтения текста;
- w — (от английского слова write) — позволяет открыть файл для записи текста. Если в файле уже присутствует какая-то информация, она будет стерта;
- a — (от английского add) — используется для открытия файла в режиме «дозаписи», при котором к существующим в файле данным будет добавлена новая информация. При этом старые данные также остаются в файле;
- rb — режим чтения двоичных данных;
- wb — режим записи двоичных файлов.
Так как нам необходимо прочитать файл, то подходящий нам режим работы с файлом — «r», который является режимом по умолчанию. А значит, нет необходимости его указывать.
Для открытия файла мы воспользовались строкой вида:
Мы не случайно использовали ключевое слово width в качестве обертки при открытии файла — этот маленький фокус гарантирует нам автоматическое закрытие файла по завершению работы с ним.
Удобно, не правда ли? Если бы за мной так прибирали посуду после извлечения из нее содержимого… Однако, такая возможность в Python появилась только в версии 2.5. До этого закрытие файла нужно было номинировать функцией close(). И выглядело это так:
Такой вариант и по сей день имеет место быть, часто используется и отлично работает. Однако первый вариант имеет «защиту от дурака», чем лично для меня повышает свою привлекательность.
2. Считываем данные из открытого файла
Для чтения содержимого файла мы использовали цикл for. Каждая новая строка считывается в переменную line, а затем выводится на экране до тех пор, пока не будет достигнут символ окончания файла EOF:
Это довольно гибкий рабочий вариант. Однако, сложно обойти стороной «святую троицу» Питоновских методов, созданных для работы с файлами:
1. Метод read(file)
Метод read(file) — считывает все данные из файла file и возвращает их в виде одной текстовой строки. Этот вариант подходит для файлов небольшого размера:
Программа выведет на экран:
2. Метод readline()
Метод readline() считывает одну строку. Для того, чтобы вывести содержимое всего файла, необходимо зациклить построчный вывод:
Результат работы кода:
3. Метод readlines()
Метод readlines() возвращает содержимое файла в виде списка строк:
Результат работы кода:
Используя метод readlines() можно легко получить доступ к нужной строке, допустим к строке с индексом 3:
Так как Python нумерует строки с 0, то 3-й индекс в моем файле принадлежит четвертой строке
Таким образом, мы научились выполнять построчное чтение файла в Python несколькими различными способами. Вы можете использовать любой из рассмотренных вариантов, в зависимости от Ваших предпочтений и особенностей задачи. Интересных Вам файлов и красивых строк! ��