Считывание из файла python: Работа с файлами

Содержание

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

В Python есть несколько способов прочитать текстовый файл. В этой статье мы рассмотрим функцию open(), методы read(), readline(), readlines(), close() и ключевое слово with.

Как открыть текстовый файл в Python с помощью open()

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

Вот так выглядит основной синтаксис функции open():

open("name of file you want opened", "optional mode")

Имена файлов и правильные пути

Если текстовый файл, который нужно открыть, и ваш текущий файл находятся в одной директории (папке), можно просто указать имя файла внутри функции open(). Например:

open ("demo. txt")

На скрине видно, как выглядят файлы, находящиеся в одном каталоге:

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

В этом примере файл со случайным текстом находится в папке, отличной от той, где находится файл с кодом main.py:

В таком случае, чтобы получить доступ к этому файлу в main.py, вы должны включить имя папки с именем файла.

open("text-files/random-text.txt")

Если путь к файлу будет указан неправильно, вы получите сообщение об ошибке FileNotFoundError.

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

Необязательный параметр режима в open()

При работе с файлами существуют разные режимы. Режим по умолчанию – это режим чтения.

Он обозначается буквой r.

open("demo. txt", mode="r")

Вы также можете опустить mode= и просто написать «r».

open("demo.txt", "r")

Существуют и другие типы режимов, такие как «w» для записи или «a» для добавления. Мы не будем вдаваться в подробности о других режимах, потому что в этой статье сосредоточимся исключительно на чтении файлов.

Полный список других режимов можно найти в документации.

Дополнительные параметры для функции open() в Python

Функция open() может также принимать следующие необязательные параметры:

buffering
encoding
errors
newline
closefd
opener

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

Мини-задача на разогрев: являются ли две строки анаграммами?

Метод readable(): проверка доступности файла для чтения

Если вы хотите проверить, можно ли прочитать файл, используйте метод readable(). Он возвращает True или False.

Следующий пример вернет True, потому что мы находимся в режиме чтения:

file = open("demo.txt")
print(file.readable())

Если бы мы изменили этот пример на режим

«w» (для записи), тогда метод readable() вернул бы False:

file = open("demo.txt", "w")
print(file.readable())

Что такое метод read() в Python?

Метод read() будет считывать все содержимое файла как одну строку. Это хороший метод, если в вашем текстовом файле мало содержимого .

В этом примере давайте используем метод read() для вывода на экран списка имен из файла demo. txt:

file = open("demo.txt")
print(file.read())

Запустим этот код и получим следующий вывод:

# Output:
# This is a list of names:
# Jessica
# James
# Nick
# Sara

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

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

file = open("demo. txt")
print(file.read(4))
# Output:
# This

Если аргумент размера опущен или число отрицательное, то будет прочитан весь файл.

Что такое метод close() в Python?

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

Вот пример того, как закрыть файл demo.txt:

file = open("demo.txt")
print(file.read())
file.close()

Как использовать ключевое слово with в Python

Один из способов убедиться, что ваш файл закрыт, – использовать ключевое слово with. Это считается хорошей практикой, потому что файл закрывается не вручную, а автоматически. Более того, это просто крайне удобно и защищает вас от ошибок, которые могут возникнуть, если вы случайно забудете закрыть файл.

Давайте попробуем переписать наш пример, используя ключевое слово with:


 with open("demo. txt") as file:
    print(file.read())

Что такое метод readline() в Python?

Этот метод читает одну строку из файла и возвращает ее.

В следующем примере у нас есть текстовый файл с двумя предложениями:

This is the first line
This is the second line

Если мы воспользуемся методом readline(), он выведет нам только первое предложение нашего файла.

 with open("demo.txt") as file:
    print(file.readline())
# Output:
# This is the first line

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

with open("demo. txt") as file:
    print(file.readline(7))

Что такое метод readlines() в Python?

Этот метод читает и возвращает список всех строк в файле.

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


 Grosery Store List:
Chicken
Mango
Rice
Chocolate Cake

В следующем примере давайте выведем наши продукты в виде списка с помощью метода readlines().

with open("demo.txt") as file:
    print(file.readlines())
# Output:
# ['Grocery Store List:\n', 'Chicken\n', 'Mangos\n', 'Rice\n', 'Chocolate Cake\n']

Как прочитать текстовый файл при помощи цикла for

В качестве альтернативы методам чтения можно использовать цикл for.

Давайте распечатаем все элементы файла demo.txt, перебирая объект в цикле for.

  with open("demo.txt") as file:
    for item in file:
        print(item)

Запустим наш код и получим следующий результат:

# Output:
# Grocery Store List:
# Chicken
# Mango
# Rice
# Chocolate Cake

Заключение

Итак, если вы хотите прочитать текстовый файл в Python, вам сначала нужно его открыть.

open("name of file you want opened", "optional mode")

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

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

Функция open() принимает необязательный параметр режима. Режим по умолчанию – чтение («r»).

Чтобы проверить, можно ли прочитать текстовый файл, вы можете использовать метод readable(). Он возвращает True, если файл можно прочитать, или False в противном случае.

Метод read() будет читать все содержимое файла как одну строку.

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

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

Метод readlines() прочитает и вернет все строки в файле в виде списка.

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

Надеемся, вам понравилась эта статья. Желаем удачи в вашем путешествии по миру Python!

Перевод статьи «Python Open File – How to Read a Text File Line by Line».

Чтение файлов в Python | PyLab

Причин для того, чтобы возникла необходимость прочитать файл огромное множество. Может быть вам понадобилось прочитать текстовый файл, например, log-file, или XML, в целях извлечения данных. Иногда это становится трудной задачей. Не беспокойтесь, Питон не является каверзным в данном вопросе. Существует два способа при помощи которых Питон сможет прочитать файл. Для простоты, мы дадим Питону прочитать текстовые файлы, но не стесняйтесь попробовать прочитать XML самостоятельно.

Открываем файлы

Допустим, у нас есть удивительный файл test.txt, который заполнен каким-то случайным текстом. Теперь, в примере, у нас есть наш код. Также как и вы должны определится с файлом, прежде чем на него щелкнуть, так и Python должен знать, какой файл открыть. Таким образом, мы используем метод open, чтобы сказать Python, что мы от него хотим, а именно открыть его. “r” просто говорит Python, что мы хотим прочитать (“w”, когда мы хотим что-то записать в файл). И, конечно же, мы связываем это с переменной, чтобы мы могли это использовать позже. Тем не менее, мы только открыли файл, и согласитесь, что пока это не так интересно. Давайте попробуем прочитать файл.

Чтение файла

file.read(n) – Данный метод читает n количество знаков из файла, или если n – пусто, то читает полностью весь файл.
file.readline(n) – Данный метод читает полностью весь файл.

Итак, это может показаться небольшой путаницей. Во-первых, мы открываем файл, как и ожидалось. Далее, мы используем read(1), и обратите внимание, что мы предоставили аргумент 1, который просто означает, что мы хотим прочитать следующий символ. Так, Python печатает “Я” для нас, потому что это первый символ в файле test. txt. Что происходит дальше, немного странно. Мы даем задачу Питону прочитать весь файл при помощи read(). Но разве он не включает в себя тот символ, который мы уже прочитали? Так происходит потому, что Питон просто продолжит с того момента, где он был прерван. Так что, если Python уже прочитал «Я», он начнет чтение со следующего символа. Это сделано для того, чтобы вы могли пролистать содержимое файла без необходимости пропуска большого количества данных каждый раз, когда вы хотите перейти к новому символу. Питон ленив, он не хочет возвращаться и перечитывать содержимое.

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

Происходит что-то странное… Во-первых, не берите в голову \n. Это всего лишь символ, означающий новую строку. Питон хочет сохранить существующий формат. Мы открываем файл как обычно, и создаем лист. Затем, мы разбиваем файл на линии, используя ключевые слова. Питон довольно сообразителен и понимает, что от него требуется. Потом, мы используем myList.append(line), чтобы добавить каждую линию в наш лист myList. Наконец, мы отправляем на печать и видим, что нам выдал Питон. Он разил каждую линию файла на строку (string), которыми мы впоследствии сможем делать то, что захотим.

Подождите! Не забудьте закрыть файл!

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

Поделитесь с друзьями:

Чтение файлов в Python — PYnative

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

В Python временные данные, которые локально используются в модуле, будут храниться в переменной. В больших объемах данных используются файлы, такие как текстовые и CSV-файлы, и в Python есть методы для чтения или записи данных в эти файлы.

После прочтения этого руководства вы узнаете : –

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

Содержание

Режимы доступа для чтения файла

Шаги для чтения файла в Python

Пример: чтение текстового файла0012
readline(): чтение файла построчно
- чтение первых N строк из файла с помощью readline()
- чтение всего файла с помощью readline()
- чтение первой и последней строки с помощью readline()
readlines(): Чтение файла в список
- Чтение первых N строк из файла
- Чтение последних N строк в файле
Чтение N байтов из файла
Чтение и запись в один и тот же файл
- Чтение файла в обратном порядке
Чтение бинарного файла

Режимы доступа для чтения файла

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

Ниже приведены различные режимы чтения файла. Мы увидим каждого по очереди.

Режим файла	Определение
`r`	Режим по умолчанию для открытия файла для чтения содержимого текстового файла.
`r+`	Открытие файла для чтения и записи. Указатель файла будет помещен в начало файла.
`rb`	Открывает файл для чтения файла в двоичном формате. Указатель файла будет помещен в начало файла.
`w+`	Открывает файл как для записи, так и для чтения. Указатель файла будет помещен в начало файла. Для существующего файла содержимое будет перезаписано.
`a+`	Откройте файл как для чтения, так и для добавления. Указатель будет помещен в конец файла, а новое содержимое будет записано после существующего содержимого.

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

Шаги для чтения файла в Python

Чтобы прочитать файл, выполните следующие действия:

Найдите путь к файлу
Мы можем прочитать файл, используя как относительный, так и абсолютный путь. Путь — это расположение файла на диске.
Абсолютный путь содержит полный список каталогов, необходимый для поиска файла.
Относительный путь содержит текущий каталог, а затем имя файла.
Открыть файл в режиме чтения
Чтобы открыть файл Передайте путь к файлу и режим доступа к функция open() . Режим доступа определяет операцию, которую вы хотите выполнить с файлом, например чтение или запись. Например, r для чтения.
Например, fp= open(r'File_Path', 'r')
Чтение содержимого из файла.
После открытия мы можем прочитать весь текст или содержимое файла, используя метод read() . Вы также можете использовать readline() для чтения файла построчно или readlines() , чтобы прочитать все строки.
Например, content = fp.read()
Закрыть файл после завершения операции чтения
Нам нужно убедиться, что файл будет правильно закрыт после завершения файловой операции. Используйте fp.close() , чтобы закрыть файл.

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

Следующий код показывает , как читать текстовый файл в Python.

Текстовый файл (плоский файл) — это компьютерный файл, структурированный как последовательность строк электронного текста.

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

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

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

 # чтение файла с абсолютным путем
пытаться:
    fp = open(r"E:\demos\files\read_demo.txt", "r")
    печать (fp.read())
    fp.close()
кроме FileNotFoundError:
    print("Пожалуйста, проверьте путь")

Вывод

 Первая строка
Вторая линия
Третья линия
Четвертая линия
Пятая строка

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

Например, E:\PYnative\files_demos\read_demo.txt — это абсолютный путь для обнаружения файла read_demo.txt. Вся информация, необходимая для поиска файла, содержится в строке пути.

При открытии файла для чтения его содержимого мы всегда проверяли, что указываем правильный путь. Если файл отсутствует по указанному пути, мы получим FileNotFoundError

Этого можно избежать, поместив код открытия файла в блок try-except-finally .

Чтение файла с помощью оператора

with

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

 with open(__file__, accessmode) as f:

Ниже приведены основные преимущества открытия файла с помощью оператора with

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

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

 # Чтение файлов с помощью 'with'
с open('read_demo.txt', 'r') в виде файла:
    print(file.read())

Вывод

 Первая строка
Вторая линия
Третья линия
Четвертая линия
Пятая линия

Методы чтения файла

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

Метод	Когда использовать?
`read()`	Возвращает все содержимое файла и принимает необязательный параметр размера, который указывает количество байтов для чтения из файла.
`readline()`	Метод `readline()` считывает из файла по одной строке за раз. . Принимает необязательный параметр размера, который указывает, сколько байтов нужно вернуть из файла.
`readlines()`	Метод `readlines` () возвращает список строк из файла.

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

readline() : чтение файла построчно

Используя метод readline() , мы можем прочитать файл построчно0008 . по умолчанию этот метод читает первую строку в файле.

Например, если вы хотите прочитать первые пять строк из текстового файла, запустите цикл пять раз и используйте метод readline() в теле цикла. Используя этот подход, мы можем прочитать определенное количество строк.

 readline(n)

Здесь n представляет количество байтов, которое нужно прочитать из файла. Этот метод прочитает строку и добавит в конец строки символ новой строки «\n». При чтении текстового файла этот метод вернет строку.

 с open('read_demo.txt', 'r') как fp:
    # прочитать первую строку
    # присвоить его строковой переменной
    строка = fp.readline()
    print(line)

Вывод

 Первая строка

Чтение первых N строк из файла с помощью

readline()
Мы можем прочитать первые несколько строк из файла с помощью readline() метод. Запустите цикл несколько раз, используя цикл for и функцию range(), и используйте метод readline() в теле цикла.
Пример :
с файлом open('read_demo.txt', 'r'): # прочитать первые 3 строки для я в диапазоне (3): print(file. readline().strip())
Вывод
Первая строка Вторая линия Третья строка
Чтение всего файла с помощью
readline()
Мы можем использовать метод readline() для чтения всего файла с помощью цикла while. Нам нужно проверить, достиг ли указатель конца файла, а затем выполнить цикл по строке файла.
с open('read_demo.txt', 'r') как fp: # прочитать первую строку строка = fp.readline() # Итерировать файл, пока он не достигнет EOF а строка != '': печать (строка, конец = '') строка = fp.readline()
Вывод
Первая строка Вторая линия Третья линия Четвертая линия Пятая строка
Чтение первой и последней строки с помощью
readline()
Мы можем прочитать первую и последнюю строки файла с помощью метода readline() . Мы можем получить первую линию, просто позвонив в readline() , так как этот метод всегда начинает чтение с начала, и мы можем использовать цикл for , чтобы получить последнюю строку. Это лучшее решение с точки зрения экономии памяти, поскольку мы не считываем весь файл в память.
Мы можем лучше понять это на примере.
с open("read_demo.txt", "r") в виде файла: # чтение первой строки первая_строка = файл.readline() печать (первая_строка) для last_line в файле: проходить # печатаем последнюю строку печать (последняя_строка)
Выход
Первая строка Пятая строка
readlines() : Чтение файла в список
Хотя мы видели, как извлечь все содержимое файла с помощью метода readline() , мы можем добиться того же, используя метод readlines() . Этот метод читает файл построчно в список .
readlines()
Этот метод возвращает все содержимое файла. Чтение содержимого начнется с начала файла, пока не достигнет EOF (конец файла).
Этот метод будет внутренне вызывать метод readline() и сохранять содержимое в списке. Результатом этого метода является список.
с open('read_demo.txt', 'r') как fp: # Прочитать файл в список строки = fp.readlines() print(lines)
Вывод
['Первая строка\n', 'Вторая строка\n', 'Третья строка\n', 'Четвертая строка\n', 'Пятая строка']
Как мы можем см., что каждая новая строка добавляется как отдельная запись в списке с добавлением символа новой строки в конце.
Чтение первых N строк из файла
Хотя метод read() считывает все содержимое файла, мы можем прочитать только несколько первых строк, перебирая содержимое файла.
Давайте разберемся на примере. Здесь мы передаем значение N (количество строк) с самого начала как 2, и оно вернет только первые две строки файла.
Н = 2 с open("readdemo.txt","r") в качестве файла: head = [следующий (файл) для x в диапазоне (N)] печать (голова)
Вывод
['Первая строка\n', 'Вторая строка\n']
Чтение последних N строк в файле
Как мы все знаем, метод readlines() вернет весь файл содержимое в виде списка. Мы можем получить последние несколько строк файла, используя индекс списка и нарезку.
n = 2 с open('readdemo.txt', 'r') как f: строки = f.readlines()[n:] print(lines)
Вывод
['Третья строка\n', 'Четвертая строка\n', 'Пятая строка']
В приведенном выше примере мы видели, как мы можем прочитать последние 3 строки в файле, используя нарезку списка.
Чтение N байтов из файла
Метод read()
read([n])
Здесь n представляет количество байтов для чтения. Если ничего не передается, то будет прочитано все содержимое файла.
В то время как метод read() читает весь файл, мы можем прочитать только определенное количество байтов из файла, передав параметр «n» в метод read() .
Давайте посмотрим, как прочитать только первые 30 байт из файла.
# прочитать файл с абсолютным путем пытаться: fp = open(r"E:\demos\files_demos\read_demo. txt", "r") печать (fp.read (30)) fp.close() кроме FileNotFoundError: print("Пожалуйста, проверьте путь.")
Вывод
Первая строка Вторая линия Третий l
Чтение и запись в один и тот же файл
Давайте посмотрим, как выполнять несколько операций в одном файле. Всякий раз, когда мы пытаемся выполнить дополнительную операцию после открытия файла, она выдает 'Неподдерживаемая операция' исключение. Если мы попытаемся записать файл после его открытия для операции чтения, это исключение будет выдано.
с open('readdemo.txt', 'r') как f: печать (f.read()) f.write("Чтение свежего")
Вывод
UnsupportedOperation: недоступно для записи
Мы можем избежать этого исключения, изменив режим доступа на r+ . При установленном режиме доступа r+ дескриптор файла будет помещен в начало файла, и тогда мы сможем прочитать все содержимое. С write() метод, вызванный для файлового объекта, мы можем перезаписать существующее содержимое новым содержимым.
Но когда мы читаем с помощью r+ , дескриптор файла будет в начале, и мы должны убедиться, что существует файл с переданным именем. В противном случае мы получим исключение FileNotFound .
с open('read_demo.txt', 'r+') как f: # читать с начала печать (f.read()) # Запись в файл # запись в текущей позиции f.write("\nШестая строка") # это будет читаться с текущей позиции указателя файла печать (f.read()) # запись в текущей позиции f.write("\nСедьмая строка") # это будет читаться с текущей позиции печать(f.read())
Выход
Первая строка Вторая линия Третья линия Четвертая линия Пятая линия Шестая линия Седьмая строка
Текстовый файл после операции чтения и записи
Чтение файла в обратном порядке
Мы можем прочитать содержимое файла в обратном порядке, используя метод readlines() и затем вызвав метод reversed () на list, чтобы получить содержимое списка в обратном порядке. Затем мы можем перебрать содержимое списка и распечатать значения.
с open('readdemo.txt', 'r') как f: строки = f.readlines() для строки в обратном порядке (линии): печать(строка)
Вывод
Пятая строка Четвертая линия Третья линия Вторая линия Первая строка
Чтение двоичного файла
Двоичные файлы — это в основном файлы с данными в байтовом формате (0 и 1). Обычно он не содержит EOL (конец строки), поэтому важно проверить это условие перед чтением содержимого файла.
Мы можем открыть и прочитать содержимое двоичного файла, используя оператор with, как показано ниже.
с open("Timezones.jpg", "rb") как f: byte_content = f.read(1) в то время как byte_content: #Распечатка содержимого файла print(byte_content)
В этом посте мы видели, как можно прочитать содержимое файла, используя различные методы чтения, доступные в Python. Мы также видели несколько простых примеров частичного чтения содержимого, таких как первые несколько строк или последние несколько строк, в зависимости от нашего требования.
Чтение файлов с помощью Python
Введение
Для работы с сохраненными данными обработка файлов становится основным знанием каждого профессионального программиста Python. С самого раннего выпуска Python как чтение, так и запись данных в файлы являются встроенными функциями. По сравнению с другими языками программирования, такими как C или Java, он довольно прост и требует всего несколько строк кода. Кроме того, для правильной работы не требуется загружать дополнительный модуль.
В этой статье мы объясним, как читать файлы с помощью Python на примерах. Некоторые примеры включают чтение файла построчно, как фрагмент (определенное количество строк за раз) и чтение файла за один раз. Кроме того, мы покажем вам способ чтения только определенной строки из файла без поиска по всему файлу.
Основы работы с файлами в Python
Общие методы работы с файлами: open() для открытия файла, seek() для установки текущей позиции файла с заданным смещением и close() для закройте файловый объект, когда закончите его использовать. Встроенная функция open() возвращает дескриптор файла, представляющий файловый объект, который будет использоваться для доступа к файлу для чтения, записи или добавления.
При открытии файла для чтения Python должен точно знать, как файл следует открывать в системе. Доступны два режима доступа — чтение и чтение в бинарном режиме. Соответствующие флаги используются 'r' и 'rb' и должны быть указаны при открытии файла встроенной функцией open() . Первый режим включает интерпретацию специальных символов, таких как «CR» (возврат каретки) и «LF» (перевод строки), для представления разрывов строк, тогда как двоичный режим позволяет читать данные в необработанном режиме, где данные хранятся как есть. без дальнейшего толкования.
Как только вы откроете файл, функция open() вернет вам файловый объект. Эти файловые объекты имеют такие методы, как read() , readline() , write() , tell() и seek() . Хотя некоторые файловые объекты (или файловоподобные объекты) имеют больше методов, чем перечислено здесь, они являются наиболее распространенными. Не все файловые объекты должны реализовывать все файловые методы.
Построчное чтение файла
Первый пример вдохновлен двумя языками программирования — C и C++. Это, пожалуй, самый интуитивный подход — открыть файл с помощью функции open() 9.0017, читать файл построчно, используя метод readline() , и выводить строку сразу после чтения.
Здесь используется цикл while , который непрерывно читает из файла до тех пор, пока метод readline() продолжает возвращать данные. В случае достижения конца файла (EOF) цикл в то время как останавливается и файловый объект закрывается, освобождая ресурсы для использования другими программами:
# Определите имя файла для чтения из имя файла = "test.txt" # Открыть файл для чтения дескриптор файла = открыть (имя файла, 'r') пока верно: # прочитать одну строку строка = дескриптор файла. readline() если не строка: перерыв печать (строка) # Закрываем указатель на этот файл дескриптор файла.close()
Как вы могли заметить, в этом примере мы явно открыли и закрыли файл. Хотя интерпретатор Python автоматически закрывает открытые файлы в конце выполнения программы Python, явное закрытие файла с помощью close() является хорошим стилем программирования, и его не следует забывать.
В качестве улучшения в Python 2.3 был представлен удобный протокол итератора . Это позволяет упростить цикл readline :
# Определяем имя файла для чтения имя файла = "test.txt" для строки в open(имя файла, 'r'): печать (строка)
Здесь используется цикл для в сочетании с итератором в . Текущая строка идентифицируется с помощью итератора в , читается из файла и ее содержимое выводится на stdout . Python обеспечивает открытие и закрытие файла для вас, когда он выходит за рамки. Хотя это неэффективно, это позволяет вам больше не иметь дело с файловыми дескрипторами.
К сожалению, приведенный выше код менее явный и полагается на внутреннюю сборку мусора Python для обработки закрытия файла.
Представленная в Python 2.5 команда с еще больше инкапсулирует весь процесс, а также обрабатывает открытие и закрытие файлов только один раз во всем блоке кода с заданной областью:
# Определить имя файла для чтения из имя файла = "test.txt" с открытым (имя файла, 'r') в качестве дескриптора файла: для строки в дескрипторе файла: печать (строка)
Комбинация оператора с оператором и команды open() открывает файл только один раз. В случае успеха выполняется цикл for , и содержимое строки печатается на stdout .
Кроме того, использование оператора с оператором имеет побочный эффект. Внутри интерпретатор Python создает блок try - finally для инкапсуляции чтения из файла. В следующем примере показано, что по существу происходит внутри Python с с кодовыми блоками :
попробуйте: дескриптор файла = открыть (имя файла, 'r') # Сделай что-нибудь... окончательно: дескриптор файла.close()
Чтение файла в виде кусков строк
До сих пор мы обрабатывали файл построчно. Это довольно медленно для больших файлов, и его можно улучшить, прочитав несколько строк одновременно. Для этого в игру вступает метод islice() из модуля itertools. Кроме того, он работает как итератор и возвращает блок данных, состоящий из n строк. В конце файла результат может быть короче, и, наконец, вызов вернет пустой список:
from itertools import islice # Определяем имя файла для чтения имя файла = "test.txt" # Определяем количество строк для чтения количество_линий = 5 с открытым (имя файла, 'r') в качестве входного_файла: lines_cache = islice (входной_файл, количество_линий) для current_line в lines_cache: печать (текущая_строка)
Чтение определенной строки из файла
Используя показанные выше методы, мы также можем выполнять другие полезные действия, такие как чтение определенной строки из файла. Для этого мы используем счетчик и печатаем соответствующую строку, когда доходим до него во время итерации по файлу:
# Определяем имя файла для чтения имя файла = "test.txt" # Определяем номер строки номер_строки = 3 print (f"строка {line_number} из {имя файла}: ") с открытым (имя файла, 'r') в качестве дескриптора файла: текущая_линия = 1 для строки в дескрипторе файла: если текущая_строка == номер_линии: печать (строка) перерыв текущая_строка += 1
Это должно быть просто для понимания, но немного длиннее, чем предыдущие примеры. Его можно сократить с помощью модуля linecache.
В следующем примере показано, как упростить код с помощью метода getline() . Если запрошенный номер строки выходит за пределы допустимого диапазона строк в файле, то вместо этого метод getline() возвращает пустую строку:
# Импорт модуля linecache импорт линейного кэша # Определяем имя файла для чтения имя файла = "test. txt" # Определить номер_строки номер_строки = 3 # Получить определенную строку строка = linecache.getline (имя файла, номер_строки) print (f"строка {line_number} из {имя файла}:") печать (строка)
Чтение всего файла за один раз
И последнее, но не менее важное: мы рассмотрим случай, который сильно отличается от предыдущего примера — чтение всего файла за один раз.
Имейте в виду, что в большинстве случаев у вас должно быть достаточно памяти для чтения всего файла, так как символы не занимают слишком много места, но их утомляют большие файлы. В следующем примере используется комбинация оператора with и метода read() . В этом случае мы будем использовать read() для загрузки содержимого файла в виде потока данных:
# Определите имя файла для чтения имя файла = "test.txt" с открытым (имя файла, 'r') в качестве дескриптора файла: содержимое файла = дескриптор файла.read() распечатать (содержимое файла)
Python также предлагает метод readlines() , который похож на метод readline() из первого примера. В отличие от read() содержимое файла хранится в списке, где каждая строка содержимого является элементом:
# Определяем имя файла для чтения имя файла = "test.txt" с открытым (имя файла, 'r') в качестве дескриптора файла: содержимое файла = дескриптор файла.readlines() для строки в содержимом файла: печать (строка)
В то время как readlines() будет считывать содержимое из файла до тех пор, пока оно не достигнет EOF, имейте в виду, что вы также можете ограничить объем читаемого содержимого, указав параметр sizehint , который представляет собой количество байтов для чтения.
Заключение
Как обычно, есть несколько способов прочитать содержимое файла. С точки зрения скорости все они более или менее в одной категории. Какое решение лучше всего подходит для вас, зависит от вашего конкретного случая использования. Мы думаем, что очень полезно увидеть, что возможно, а затем выбрать наиболее подходящее решение.