До конца файла Python

Обновлено: 21.11.2024

В этом посте мы узнаем, как читать и записывать файлы в Python.

Работа с файлами состоит из следующих трех шагов:

  1. Открыть файл
  2. Выполнить операцию чтения или записи
  3. Закройте файл

Давайте подробно рассмотрим каждый шаг.

Существует два типа файлов:

Текстовый файл — это просто файл, в котором хранятся последовательности символов с использованием кодировки, такой как utf-8, latin1 и т. д., тогда как в случае двоичного файла данные хранятся в том же формате, что и в памяти компьютера.

Вот несколько примеров текстовых и двоичных файлов:

Текстовые файлы: исходный код Python, файл HTML, текстовый файл, файл уценки и т. д.

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

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

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

В случае успеха open() возвращает файловый объект. При сбое вызывает IOError или его подкласс.

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

Ниже приведены возможные значения режима.

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

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

Это означает, что следующие три вызова open() эквивалентны:

Обратите внимание: прежде чем вы сможете прочитать файл, он должен уже существовать, иначе open() вызовет исключение FileNotFoundError. Однако, если вы откроете файл для записи (используя такие режимы, как w, a или r+), Python автоматически создаст файл для вас. Если файл уже существует, то его содержимое будет удалено. Если вы хотите предотвратить это, откройте файл в режиме x.

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

Чтобы закрыть файл, вызовите метод close() файлового объекта. Закрытие файла освобождает связанные с ним ресурсы и сбрасывает данные из буфера на диск.

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

Для чтения данных файловый объект предоставляет следующие методы:

Режим Описание
r Открыть файл для чтения (по умолчанию).
w Открыть файл для записи.
a< /td> Открыть файл в режиме добавления, т.е. добавить новые данные в конец файла.
r+ Открыть файл для чтения и запись обоих
x Открыть файл для записи, только если он еще не существует.
< td>Читает и возвращает n байтов или меньше (если не хватает символов для чтения) из файла в виде строки. Если n не указано, он читает весь файл как строку и возвращает ее.
Метод Аргумент
read([n])
readline() Читает и возвращает символы до конца строка достигается как строка.
readlines() Читает и возвращает все строки в виде списка строк.

Когда достигается конец файла (EOF), методы read() и readline() возвращают пустую строку, а readlines() возвращает пустой список ([]).

Вот несколько примеров:

поэма.txt

Пример 1: Использование read()

Пример 2: Использование readline()

Пример 3. Использование readlines()

Методы read() (без аргумента) и readlines() одновременно считывают все данные в память. Поэтому не используйте их для чтения больших файлов.

Лучше читать файл порциями с помощью read() или читать файл построчно с помощью readline() следующим образом:

Пример: чтение файла по частям

Пример: чтение файла построчно

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

Этот код эквивалентен предыдущему примеру, но он более лаконичный, читабельный и его легче набирать.

предупреждение:

Остерегайтесь метода readline(): если вам не повезло открыть огромный файл без символа новой строки, то readline() ничем не лучше, чем read() (без аргументов). То же самое верно, когда вы используете объект файла в качестве итератора.

Для записи данных файловый объект предоставляет следующие два метода:

Метод Описание
запись(и) Записывает строку s в файл и возвращает число записанных символов.
строки записи Записывает все строки в последовательности s в файл.

Вот примеры:

Обратите внимание, что в отличие от функции print() метод write() не добавляет символ новой строки ( \n ) в конце строки. Если вам нужен символ новой строки, вы должны добавить его вручную следующим образом:

Вы также можете добавить новую строку к строке с помощью функции print() следующим образом:

Вот пример метода writelines().

Метод writelines() внутренне вызывает метод write().

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

Предположим, что файл поэма_2.txt важен для использования, и мы не хотим, чтобы он был перезаписан. Чтобы этого не произошло, откройте файл в режиме x

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

Буферизация — это процесс временного хранения данных перед их перемещением в новое место.

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

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

Когда мы используем буфер, данные записываются на диск только тогда, когда буфер заполняется или когда вызывается метод close(). Этот процесс называется сбросом вывода. Вы также можете сбросить вывод вручную, используя метод flush() файлового объекта. Обратите внимание, что функция flush() сохраняет на диск только буферизованные данные. Файл не закрывается.

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

Чтение и запись двоичного файла выполняется путем добавления b к строке режима.

В Python 3 двоичные данные представлены с использованием специального типа, называемого bytes .

Тип bytes представляет неизменяемую последовательность чисел от 0 до 255.

Давайте создадим двоичную версию поэмы, прочитав файл поэмы.txt.

Обратите внимание, что при индексировании объекта bytes возвращается значение int .

Давайте запишем нашу бинарную поэму в новый файл.

Наша бинарная поэма теперь записана в файл. Чтобы прочитать его, откройте файл в режиме rb.

Важно отметить, что в нашем случае двоичные данные содержат печатные символы, такие как алфавиты, символы новой строки и т. д. Однако в большинстве случаев это не так. Это означает, что с двоичными данными мы не можем надежно использовать readline() и файловый объект (как итератор) для чтения содержимого файла, потому что в файле может отсутствовать символ новой строки. Лучший способ читать двоичные данные — читать их по частям с помощью метода read().

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

До сих пор мы читали и записывали файлы линейно. Но также можно читать и писать в определенных местах. Для этого файловый объект предоставляет следующие два метода:

Метод Описание
tell() Возвращает текущая позиция указателя файла.
seek(offset, [whence=0]) Перемещает указатель файла на заданное смещение. Смещение относится к количеству байтов и определяет положение, относительно которого смещение будет перемещать указатель файла. Значение по умолчанию для параметра "откуда" равно 0, что означает, что смещение приведет к перемещению указателя файла с начала файла. Если для параметра where установлено значение 1 или 2 , смещение будет перемещать указатель файла с текущей позиции или с конца файла соответственно.

Давайте рассмотрим несколько примеров.

После чтения 5 символов указатель файла теперь находится на символе a (в слове в клетке ).Таким образом, следующая операция чтения (или записи) начнется с этой точки.

Теперь мы достигли конца файла. На этом этапе мы можем использовать метод fseek() для перемотки указателя файла на начало файла следующим образом:

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

Чтобы переместить указатель файла на 12 байт вперед от текущей позиции, вызовите seek() следующим образом:

Указатель файла теперь находится на символе a (после слова с ), поэтому операции чтения и записи будут выполняться оттуда.

Мы также можем переместить указатель файла назад. Например, следующий вызов seek() перемещает указатель файла на 13 байт назад от текущей позиции.

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

Значения аргумента откуда функции fseek() также определяются как константы в модуле os.

Значение Константа
0 SEEK_SET
1 SEEK_CUR
2 SEEK_END

Инструкция with позволяет нам автоматически закрыть файл после завершения работы с ним. Его синтаксис следующий:

Инструкции внутри оператора with должны иметь такой же отступ, как и в цикле for, иначе будет возбуждено исключение SyntaxError.

Вот пример:

Другие учебные пособия (спонсоры)

Этот сайт щедро поддерживается DataCamp. DataCamp предлагает интерактивные интерактивные учебные пособия по Python для науки о данных. Присоединяйтесь к более чем миллиону других учащихся и начните изучать Python для науки о данных уже сегодня!

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

Основы работы с файлами в Python

Общие методы работы с файлами: open() для открытия файла, seek() для установки текущей позиции файла с заданным смещением и close() для закрытия файлового объекта, когда вы закончите его использовать. Метод open() возвращает дескриптор файла, представляющий файловый объект, который будет использоваться для доступа к файлу для чтения, записи или добавления.

При открытии файла для чтения Python должен точно знать, как файл следует открывать в системе. Доступны два режима доступа - чтение и чтение в двоичном режиме. Соответствующие используемые флаги r и rb должны быть указаны при открытии файла с помощью встроенного метода open(). Первый режим включает интерпретацию специальных символов, таких как «CR» (возврат каретки) и «LF» (перевод строки), для представления разрывов строк, тогда как двоичный режим позволяет вам читать данные в необработанном режиме, где данные хранятся как не требует дальнейшего толкования.

После того как вы открыли файл, метод open() вернет вам объект файла. Эти файловые объекты имеют такие методы, как read(), readline(), write(), tell() и seek(). Хотя некоторые файловые объекты (или файловоподобные объекты) имеют больше методов, чем перечислено здесь, они являются наиболее распространенными. Не все файловые объекты должны реализовывать все файловые методы.

Примеры

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

Чтение файла построчно

Первый пример вдохновлен двумя языками программирования C и C++. Это довольно просто: откройте файл с помощью метода open(), прочитайте файл построчно с помощью метода readline() и выведите строку сразу после чтения. Здесь используется цикл while, который непрерывно читает из файла до тех пор, пока метод readline() продолжает возвращать данные. В случае достижения конца файла (EOF) цикл while останавливается и файловый объект закрывается, освобождая ресурсы для использования другими программами.

Как вы могли заметить в листинге 1, мы явно открыли и закрыли файл (строки 5 и 14 соответственно). Хотя интерпретатор Python автоматически закрывает открытые файлы в конце выполнения программы Python, явное закрытие файла с помощью функции close() — это хороший стиль программирования, о котором не следует забывать.

В качестве улучшения в Python 2.3 был представлен удобный протокол итератора.Это позволяет упростить цикл readline следующим образом:

Здесь используется цикл for в сочетании с итератором in. Файл открывается в строке 4 листинга 2. Текущая строка идентифицируется с помощью итератора in, читается из файла, и ее содержимое выводится на стандартный вывод в строке 5. Python обеспечивает открытие и закрытие файла для вас, когда он выходит за рамки. Хотя это неэффективно, это позволяет вам больше не иметь дело с файловыми дескрипторами.

К сожалению, приведенный выше код менее явный и полагается на внутреннюю сборку мусора Python для обработки закрытия файла. Представленная в Python 2.5 команда with еще больше инкапсулирует весь процесс, а также обрабатывает открытие и закрытие файлов только один раз во всем блоке кода с заданной областью. В листинге 3 показано, как использовать команду with.

Комбинация оператора with и команды open() открывает файл только один раз (строка 4). В случае успеха выполняется цикл for, и содержимое строки выводится на стандартный вывод (строки 5 и 6).

Кроме того, использование оператора with имеет побочный эффект. Внутри интерпретатор Python создает блок try-finally для инкапсуляции чтения из файла. В листинге 4 показано, что происходит внутри Python с блоками кода with:

Чтение файла как фрагментов строк

До сих пор мы обрабатывали файл построчно. Это довольно медленно для больших файлов, и его можно улучшить, прочитав несколько строк одновременно. Для этого в игру вступает метод islice() из модуля itertools. Кроме того, он работает как итератор и возвращает блок данных, состоящий из n строк. В конце файла результат может быть короче, и, наконец, вызов вернет пустой список.

Чтение определенной строки из файла

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

Бесплатная электронная книга: Git Essentials

Ознакомьтесь с нашим практическим руководством по изучению Git, включающим передовые практики, общепринятые стандарты и памятку. Перестаньте гуглить команды Git и на самом деле изучите их!

Листинг 6 должен быть простым для понимания, но он немного длиннее, чем предыдущие примеры. Его можно сократить с помощью модуля linecache. В листинге 7 показано, как упростить код с помощью метода getline(). Если запрошенный номер строки выходит за пределы допустимого диапазона строк в файле, то вместо этого метод getline() возвращает пустую строку.

Чтение всего файла сразу

И последнее, но не менее важное: мы рассмотрим случай, который сильно отличается от предыдущего примера — чтение всего файла за один раз. Имейте в виду, что в большинстве случаев на вашем компьютере должно быть достаточно места для чтения всего файла в память. В листинге 8 используется комбинация оператора with и метода read(). В этом случае мы будем использовать read() для загрузки содержимого файла в виде потока данных.

Python также предлагает метод readlines(), аналогичный методу readline() из первого примера. В отличие от read() содержимое файла хранится в списке, где каждая строка содержимого является элементом. В листинге 9 показано, как получить доступ к этим данным:

Хотя функция readlines() будет считывать содержимое из файла до тех пор, пока оно не достигнет EOF, имейте в виду, что вы также можете ограничить объем считываемого содержимого, указав параметр sizehint, который представляет собой количество байтов для чтения.

Заключение

Как обычно, есть несколько способов прочитать содержимое файла. С точки зрения скорости все они более или менее в одной категории. Что касается того, какое решение лучше всего подходит для вас, зависит от вашего конкретного варианта использования. Мы думаем, что очень полезно посмотреть, что возможно, а затем выбрать наиболее подходящее решение.

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

Ресурсы

Благодарности

Автор выражает благодарность Золеке Хатитонгве за поддержку при подготовке статьи.

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

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

Пути к файлам

Чтобы открыть файл, нам нужно указать Python, где именно находится файл относительно того, где Python работает в данный момент (рабочий каталог). В Spyder мы можем сделать это, установив наш текущий рабочий каталог в папку, в которой находится файл. Или, когда мы указываем имя файла, мы можем указать полный путь к файлу.

Настройка урока

  1. Найдите файл Plates_output_simple.csv в папке home/Desktop/workshops/bash-git-python.
  2. Скопируйте файл в свой рабочий каталог, home/Desktop/workshops/YourName.
  3. Убедитесь, что в качестве рабочего каталога также указана папка home/Desktop/workshops/YourName.
  4. Во время работы обязательно сохраняйте сценарии открытия файлов в этом каталоге.

Настройка файла

Давайте откроем и изучим структуру файла Plates_output_simple.csv. Если вы откроете файл в текстовом редакторе, вы увидите, что файл содержит несколько строк текста.

Однако это довольно сложно читать. Если вы откроете файл в программе для работы с электронными таблицами, такой как LibreOfficeCalc или Excel, вы увидите, что файл организован в столбцы, где каждый столбец разделен запятыми на изображении выше (отсюда и расширение файла .csv, которое означает запятую). разделенные значения).

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

  • Название изображения, из которого были собраны данные
  • Номер пластины (было 4 пластины, каждая из которых была снята в два разных момента времени)
  • Условия выращивания (контрольные или экспериментальные).
  • Время наблюдения (24 или 48 часов)
  • Подсчет колоний на чашке
  • Средний размер колонии на чашке.
  • Процент площади чашки, покрытой бактериальными колониями.

Мы прочитаем этот файл данных, а затем проанализируем данные.

Открытие и чтение файлов – это трехэтапный процесс

.

Мы откроем и прочитаем файл в три этапа.

  1. Мы создадим переменную для хранения имени файла, который мы хотим открыть.
  2. Мы вызовем open, чтобы открыть файл.
  3. Мы вызовем функцию, которая фактически прочитает данные из файла и сохранит их в переменной, чтобы мы могли их обработать.

А потом осталось сделать еще один шаг!

  • Когда мы закончим, мы должны не забыть закрыть файл!

Эти три шага можно сравнить с получением книги в библиотеке. Во-первых, вы должны зайти в каталог или базу данных, чтобы узнать, какая книга вам нужна (имя файла). Затем вам нужно взять ее с полки и открыть книгу (функция открыть). Наконец, чтобы получить какую-либо информацию из книги, вы должны прочитать слова (функция read)!

Вот пример открытия, чтения и закрытия файла.

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

Используйте согласованные имена, чтобы сделать ваш код более понятным

Полезно выработать определенные привычки в отношении того, как вы открываете и читаете файлы. Использование одних и тех же (или похожих!) имен переменных каждый раз облегчит вам отслеживание того, какая переменная является именем файла, какая переменная является объектом открытого файла, а какая переменная содержит считываемые данные.< /p>

В этих примерах мы будем использовать filename для текстовой строки, содержащей имя файла, infile для открытого файлового объекта, из которого мы можем считывать данные, и data для переменной, содержащей содержимое файла.< /p>

Команды для чтения в файлах

Существует множество команд, которые позволяют нам считывать данные из файлов.
infile.read() будет считывать весь файл как одну строку текста.
infile.readline() будет читать по одной строке за раз (каждый раз, когда вы вызываете эту команду, она читает со следующей строки).
infile.readlines() прочитает все строки в список, где каждая строка файла является элементом списка.

Смешивание этих команд может привести к неожиданным результатам.

Обратите внимание, что команда infile.read() начинается с третьей строки файла, где заканчиваются первые две команды infile.readline().

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

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

Чтение всех строк файла в список

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

Пример ниже демонстрирует этот подход:

Использование .split() для разделения «столбцов»

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

Снова согласованные имена

На первый взгляд, имя переменной sline в приведенном выше примере может не иметь особого смысла. На самом деле, мы выбрали его как сокращение от «split line», которое точно описывает содержимое переменной.

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

Преобразование текста в числа

Когда мы вызвали команду readlines() в предыдущем коде, Python считывает содержимое файла в виде строки. Если мы хотим, чтобы наш код распознавал что-то в файле как число, мы должны сообщить ему это!

Например, float('5.0') сообщит Python обработать текстовую строку '5.0' как номер 5.0. int(sline[4]) сообщит нашему коду, что текстовую строку, хранящуюся в 5-й позиции списка sline, следует рассматривать как целое (недесятичное) число.

Для каждой строке в файле ColonyCount хранится в 5-м столбце (индекс 4 с нашим подсчетом на основе 0).
Измените приведенный выше код, чтобы он печатал строку только в том случае, если ColonyCount больше 30.

Решение

Запись данных в файл

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

Запись файла — это тот же многоэтапный процесс

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

  1. Создайте переменную для хранения имени файла, который мы хотим открыть. Часто это будет новый файл, которого еще не существует.
  2. Вызовите функцию, чтобы открыть файл. На этот раз мы укажем, что открываем файл для записи в него!
  3. Запишите данные в файл. Это требует особого внимания к форматированию.
  4. Когда мы закончим, мы должны не забыть закрыть файл!

В приведенном ниже коде показан пример записи в файл:

Где оказался мой файл?

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

цитата>

Символы новой строки

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

В приведенном ниже примере показано, как использовать символы новой строки:

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

Работа с символами новой строки при чтении файла

Вы, возможно, заметили в последнем примере чтения файла, что напечатанный вывод включал символы новой строки в конце каждой строки файла:

['colonies02.tif', '2', 'exp ', '24', '84', '3.2', '22\n']
['colonies03.tif', '3', 'exp', '24', '792', '3' , '78\n']
['colonies06.tif', '2', 'exp', '48', '85', '5.2', '46\n']

Мы можем избавиться от этих новых строк с помощью функции .strip(), которая избавится от символов новой строки:

Запись чисел в файлы

Точно так же, как Python автоматически считывает файлы в виде строк, функция write() ожидает только записи строк. Если мы хотим записать числа в файл, нам нужно будет преобразовать их в строки с помощью функции str() .

В приведенном ниже коде показан пример этого:

Написание новых строк и чисел

Откройте и проверьте файл, который вы только что написали. Вы увидите, что все числа записаны в одной строке.

Измените код, чтобы каждое число записывалось в отдельной строке.

Решение

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

Открытие файлов в разных «режимах»

Когда мы открывали файлы для чтения или записи данных, мы использовали параметр функции «r» или «w», чтобы указать, каким «способом» открыть файл.
'r' указывает, что мы открываем файл для чтения данных из него.
'w' означает, что мы открываем файл для записи в него данных.

Будьте очень-очень осторожны при открытии существующего файла в режиме 'w'.
'w' перезапишет любые данные, которые уже есть в файле! Перезаписанные данные будут потеряны!

Если вы хотите добавить то, что уже есть в файле (вместо того, чтобы стирать и перезаписывать его), вы можете открыть файл в режиме добавления< /em>, используя вместо этого параметр 'a'.

Python readline() — это файловый метод, который помогает прочитать одну полную строку из заданного файла. Он имеет завершающую новую строку («\n») в конце возвращаемой строки.

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

Последовательность операций readline() хорошо видна на снимке экрана ниже:

У вас есть файл demo.txt, и при использовании readline() возвращается самая первая строка из demo.txt.

Из этого руководства вы узнаете:

Характеристика Python readline()

Вот важные характеристики строки чтения Python:

  • Метод Python readline() считывает только одну полную строку из заданного файла.
  • Добавляет новую строку ("\n") в конец строки.
  • Если вы откроете файл в обычном режиме чтения, функция readline() вернет вам строку.
  • Если вы откроете файл в двоичном режиме, readline() вернет вам двоичный объект.
  • Вы можете указать размер в качестве аргумента функции readline(), и она даст вам строку в соответствии с заданным размером, включая новую строку. По умолчанию размер равен 0, и возвращается вся строка.

Синтаксис

Параметры

размер: (необязательно) Здесь вы можете указать число, целочисленное значение для readline(). Он получит строку такого размера. По умолчанию значение size равно -1, поэтому возвращается вся строка.

Возвращаемое значение

Метод readline() возвращает строку из указанного файла.

Пример: чтение первой строки с помощью readline()

Здесь будет понятно, как читать строку из файла, заданную с помощью метода readline(). Здесь мы воспользуемся файлом demo.txt, чтобы прочитать его содержимое.

Содержимое файла demo.txt следующее:

Ниже приведены шаги для чтения строки из файла demo.txt.

Шаг 1)

Сначала откройте файл с помощью метода file open(), как показано ниже:

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

Шаг 2)

Используйте метод readline(), чтобы прочитать строку из файла demo.txt, как показано ниже:

Шаг 3)

Прочитанная строка сохраняется внутри myline. Давайте теперь напечатаем строку, чтобы увидеть подробности:

Шаг 4)

После завершения чтения закройте файл с помощью метода close(), как показано ниже:

Весь код выглядит следующим образом:

Пример: использование аргумента размера в readline()

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

В данном примере параметр размера задан равным 10. Будет выбрана первая строка, и она вернет строку с символами от 0 до 10.

Мы собираемся использовать файл demo.txt, использованный ранее. Сохраните файл demo.txt и используйте расположение demo.txt внутри функции open().

Базовый файловый ввод-вывод в Python

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

Следующие доступны режимы, которые можно использовать с методом open():

< td>Режим wb откроет файл для записи двоичных данных.
Режим Описание
R Это откроет() файл в режиме чтения.
W Используя w, вы можете писать в файл.
a Использование a с open() откроет файл в режиме записи, а содержимое будет добавлено в конце.
rb Режим rb откроет файл для чтения двоичных данных.
wb

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

Построчное чтение файла в Python

Метод readline() помогает читать только одну строку за раз и возвращает первую строку из заданного файла.

Сохраните файл demo.txt и используйте расположение demo.txt внутри функции open().

Использование readline() внутри цикла while позаботится о чтении всех строк, присутствующих в файле demo.txt.

Как прочитать сразу все строки в файле?

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

Функция readlines() читает до конца файла, используя внутреннюю функцию readline(), и возвращает список со всеми строками, прочитанными из файла.

Вот рабочий пример чтения всех строк из файла с помощью readlines().

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

test.txt: сохраните файл test.txt и используйте расположение test.txt внутри функции open().

Вывод:

Как прочитать файл построчно, используя цикл for?

Ниже приведены шаги для построчного чтения из заданного файла с использованием цикла for:

Шаг 1:

Сначала откройте файл с помощью функции Python open() в режиме чтения.

Шаг 2:

Функция open() вернет обработчик файла. Используйте обработчик файлов внутри цикла for и прочитайте все строки из заданного файла построчно.

Шаг 3:

После этого закройте обработчик файла с помощью функции close().

Вот рабочий пример использования цикла for для построчного чтения из заданного файла. Здесь мы будем использовать файл test.txt.

Содержимое файла test.txt показано ниже. Сохраните файл test.txt и используйте расположение test.txt внутри функции open().

Вывод:

Как прочитать файл построчно, используя цикл while?

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

Функция Python readline() используется внутри цикла while для чтения строк. В случае цикла for цикл завершается, когда встречается конец файла. Но то же самое не относится к циклу while, и вам нужно постоянно проверять, закончилось ли чтение файла. Поэтому, как только функция readline() вернет пустую строку, вы можете использовать оператор break для выхода из цикла while.

Вот рабочий пример чтения файла построчно с использованием цикла while.

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