Python файлы: Работа с файлами в python. Чтение и запись в файл ~ PythonRu

Содержание

Существует ли файл в Python, примеры os.path.exists() и os.path.isfile()

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

Способность проверять, существует ли файл на диске или нет — очень важно для большинства программ Python:

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

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

В данном руководстве вы увидите три отдельные техники для проверки существования файла в Python, с примерами кода и характерными преимуещствами и недостатками.

Приступим!

Проверяем если файл существует os.path.exists() и os.path.isfile()

Самый простой способ проверки существования файла в Python — это использование методов exists() и isfile() из модуля os.path в стандартной библиотеке.

Эти функции доступны в Python 2 и Python 3.7, и обычно их рекомендуют в первую очередь, если обращаться за помощью к документации Python или гуглу за решением проблемы.

Совет от администрации: Как не потратить каникулы в пустую?

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

Отвечаем сразу всем кто пишет нам в Telegram "С чего начать изучение Python?". Вот курс, пройдите его!

Получите сертификат!
И вы будете на голову выше остальных кандидатов!

Вот пример того, как работать с функцией os. path.exists(). Мы проверим несколько путей (файлы и папки) на наличие:

import os.path check_file = os.path.exists('storage/music.mp3') # True print(os.path.exists('нет-такого-файла.txt')) # False # Проверяем если папка существует. os.path.exists('storage') # True

import os.path

 

check_file = os.path.exists('storage/music.mp3') # True

print(os.path.exists('нет-такого-файла.txt')) # False

 

# Проверяем если папка существует.

os.path.exists('storage') # True

Как мы видим, вызов os.path.exists() возвращает True для файлов и папок. Если вы хотите убедиться, что заданный путь указывает на файл, но не на папку, вы можете использовать функцию os.path.isfile()

import os.path os.path.isfile('storage/music. mp3') # True os.path.isfile('нет-такого-файла.txt') # False os.path.isfile('storage') # False, папка существует но это не файл.

import os.path

 

os.path.isfile('storage/music.mp3') # True

os.path.isfile('нет-такого-файла.txt') # False

os.path.isfile('storage') # False, папка существует но это не файл.

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

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

Проверка существует ли файл используя open() и try … except

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

Есть еще один прямолинейный алгоритм Python для проверки существования файла: Вы просто пытаетесь открыть файл при помощи встроенной функции open(), вот так:

open('нет-такого-файла.txt') FileNotFoundError: "[Errno 2] No such file or directory: 'нет-такого-файла.txt'"

open('нет-такого-файла.txt')

    FileNotFoundError:

"[Errno 2] No such file or directory: 'нет-такого-файла.txt'"

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

Ошибка FileNotFoundError возникает, когда файл или папка запрошена, но не существует. Относится к errno ENOENT.

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

try: f = open('нет-такого-файла.txt') f.close() except FileNotFoundError: print('Файл не существует!')

try:

    f = open('нет-такого-файла.txt')

    f.close()

except FileNotFoundError:

    print('Файл не существует!')

Обратите внимание, мы мгновенно вызываем метод close() для объекта файла для освобождения дескриптора файла. Это считается хорошей практикой при работе с файлами в Python:

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

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

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

FileNotFoundError, вам нужно искать любые ошибки типа IOError:

try: f = open('new-music.mp3') f.close() except IOError: print('Файл недоступен') print('Файл доступен')

try:

    f = open('new-music.mp3')

    f.close()

except IOError:

    print('Файл недоступен')

print('Файл доступен')

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

def is_accessible(path, mode='r'): """ Проверка, является ли файл или папка из `path` доступным для работы в предоставленным `mode` формате. """ try: f = open(path, mode) f.close() except IOError: return False return True

def is_accessible(path, mode='r'):

    """

    Проверка, является ли файл или папка из `path`

    доступным для работы в предоставленным `mode` формате.

    """

    try:

        f = open(path, mode)

        f.close()

    except IOError:

        return False

    return True

Как альтернатива, вы можете использовать функцию os.access() из стандартной библиотеке для проверки того, существует ли файл и является ли он доступным в то же время. Это может быть похоже на использование функции path.exists(), если файл существует.

Использование open() и try ... except имеет некоторые преимущества, когда доходит до обработки файлов в Python. Это может помочь вам избежать накладок, вызванных определенными условиями существования файла:

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

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

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

Пример проверки существования файла pathlib.Path.exists() (Python 3.4+)

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

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

Чтобы узнать, указывает ли путь на настоящий файл, вы можете использовать метод Path.exists(). Чтобы узнать, является путь файлом, или символической ссылкой, а не папкой, вам захочется воспользоваться Path.is_file().

Вот рабочий пример для обоих методов pathlib.Path

:

import pathlib path = pathlib.Path('music.mp3') print(path.exists()) # True print(path.is_file()) # True

import pathlib

 

path = pathlib.Path('music.mp3')

print(path.exists()) # True

print(path.is_file()) # True

Как мы видим, этот подход по своему принципу схож с проверкой при помощи функций из модуля os.path.

Главное отличие в том, что pathlib предоставляет более чистый объекно-ориентированный интерфейс для работы с файловой системой. Вам больше не нужно работать с объектами str, представляющими пути файлов — вместо этого, вы обрабатываете объекты Path с релевантными методами и связанными с ними атрибутами.

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

Модуль pathlib также доступен как сторонний модуль с бэкпортом для PyPl, который работает на Python 2.x и 3.х Вы можете найти его здесь: pathlib2.

Подведем итоги проверки на наличие файла в Python

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

Конечно, имея в распоряжении три способа, вы можете подумать:

Какой способ проверки наличия файла при помощи Python является предпочтительнее?

В большинстве случаев, когда вам нужно проверить наличие файла, рекомендуется использование встроенного метода pathlib. Path.exists() на Python 3.4 и выше, или функцию os.path.exists() для Python 2.

Однако, есть одна важная оговорка…

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

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

Чтобы избежать такой ситуации, стоит опираться не только на вопрос “существует ли файл?”. Вместо этого, неплохо просто попытаться сразу выполнить желаемую операцию. Это также называется “easier to ask for forgiveness than permission” (EAFP) (проще просить прощения, чем разрешения). Такой подход часто рекомендуется при работе с Python.

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

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

Python 3: файлы - чтение и запись: open, read, write, seek, readline, dump, load, pickle

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

open(file [, mode=’r’, encoding=None, …])

через которую и осуществляется работа с файлами. Здесь

  • file – это путь к файлу вместе с его именем;
  • mode – режим доступа к файлу;
  • encoding – кодировка файла.

Для начала определимся с понятием «путь к файлу». Представим, что наш файл ex1.py находится в каталоге app:

Тогда, чтобы обратиться к файлу my_file.txt путь можно записать так:

"my_file.txt"

или

"d:\\app\\my_file.txt"

или так:

"d:/app/my_file.txt"

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

Теперь, предположим, мы хотим обратиться к файлу img.txt. Это можно сделать так:

"images/img.txt"

или так:

"d:/app/images/img.txt"

Для доступа к out.txt пути будут записаны так:

"../out.txt"

"d:/out.txt"

Обратите внимание, здесь две точки означают переход к родительскому каталогу, то есть, выход из каталога app на один уровень вверх.

И, наконец, для доступа к файлу prt.dat пути запишутся так:

"../parent/prt.dat"

"d:/ parent/prt.dat"

Вот так следует прописывать пути к файлам. В нашем случае мы имеем текстовый файл «myfile.txt», который находится в том же каталоге, что и программа ex1.py, поэтому путь можно записать просто указав имя файла:

file = open("myfile.txt")

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

file = open("myfile2.txt")

то возникнет ошибка FileNotFoundError. Это стандартное исключение и как их обрабатывать мы с вами говорили на предыдущем занятии. Поэтому, запишем этот критический код в блоке try:

try:
    file = open("myfile2.txt")
except FileNotFoundError:
    print("Невозможно открыть файл")

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

mode = "r"

Если нам нужно поменять режим доступа к файлу, например, открыть его на запись, то это явно указывается вторым параметром функции open:

file = open("out.txt", "w")

В Python имеются следующие режимы доступа:

Название

Описание

'r'

открытие на чтение (значение по умолчанию)

'w'

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

'x'

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

'a'

открытие на дозапись (информация добавляется в конец файла)

Дополнения

'b'

открытие в бинарном режиме доступа к информации файла

't'

открытие в текстовом режиме доступа (если явно не указывается, то используется по умолчанию)

'+'

открытие на чтение и запись одновременно

Здесь мы имеем три основных режима доступа: на чтение, запись и добавление. И еще три возможных расширения этих режимов, например,

  • 'rt' – чтение в текстовом режиме;
  • 'wb' – запись в бинарном режиме;
  • 'a+' – дозапись или чтение данных из файла.

Чтение информации из файла

В чем отличие текстового режима от бинарного мы поговорим позже, а сейчас откроем файл на чтение в текстовом режиме:

file = open("myfile.txt")

и прочитаем его содержимое с помощью метода read:

В результате, получим строку, в которой будет находиться прочитанное содержимое. Действительно, в этом файле находятся эти строчки из поэмы Пушкина А.С. «Медный всадник». И здесь есть один тонкий момент. Наш текстовый файл имеет кодировку Windows-1251 и эта кодировка используется по умолчанию в функции read. Но, если изменить кодировку файла, например, на популярную UTF-8, то после запуска программы увидим в консоли вот такую белиберду. Как это можно исправить, не меняя кодировки самого файла? Для этого следует воспользоваться именованным параметром encoding и записать метод open вот так:

file = open("myfile.txt", encoding="utf-8" )

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

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

print( file.read(2) )
print( file.read(2) )

то увидим, что при следующем вызове метод read продолжил читать следующие два символа. Почему так произошло? Дело в том, что у файлового объекта, на который ссылается переменная file, имеется внутренний указатель позиции (file position), который показывает с какого места производить считывание информации.

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

Но мы в Python можем управлять этой файловой позицией с помощью метода

seek(offset[, from_what])

Например, вот такая запись:

будет означать, что мы устанавливаем позицию в начало и тогда такие строчки:

print( file.read(2) )
file.seek(0)
print( file.read(2) )

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

pos = file.tell()
print( pos )

Следующий полезный метод – это readline позволяет построчно считывать информацию из текстового файла:

s = file.readline()
print( s )

Здесь концом строки считается символ переноса ‘\n’, либо конец файла. Причем, этот символ переноса строки будет также присутствовать в строке. Мы в этом можем убедиться, вызвав дважды эту функцию:

    print( file.readline() )
    print( file.readline() )

Здесь в консоли строчки будут разделены пустой строкой. Это как раз из-за того, что один перенос идет из прочитанной строки, а второй добавляется самой функцией print. Поэтому, если их записать вот так:

    print( file.readline(), end="" )
    print( file.readline(), end="" )

то вывод будет построчным с одним переносом.

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

    for line in file:
        print( line, end="" )

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

Или же, все строчки можно прочитать методом

и тогда переменная s будет ссылаться на упорядоченный список с этими строками:

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

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

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

try:
    file = open("myfile.txt")
 
    try:
        s = file.readlines()
        print( s )
    finally:
        file.close()
 
except FileNotFoundError:
    print("Невозможно открыть файл")

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

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

try:
    with open("myfile.txt", "r") as file:      # file = open("myfile.txt")
        s = file.readlines()
        print( s )
 
except FileNotFoundError:
    print("Невозможно открыть файл")

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

finally:
    print(file.closed)

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

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

Запись информации в файл

Теперь давайте посмотрим, как происходит запись информации в файл. Во-первых, нам нужно открыть файл на запись, например, так:

file = open("out.txt", "w")

и далее вызвать метод write:

file.write("Hello World!")

В результате у нас будет создан файл out.txt со строкой «Hello World!». Причем, этот файл будет располагаться в том же каталоге, что и файл с текстом программы на Python.

Далее сделаем такую операцию: запишем метод write следующим образом:

И снова выполним эту программу. Смотрите, в нашем файле out.txt прежнее содержимое исчезло и появилось новое – строка «Hello». То есть, когда мы открываем файл на запись в режимах

w, wt, wb,

то прежнее содержимое файла удаляется. Вот этот момент следует всегда помнить.

Теперь посмотрим, что будет, если вызвать метод write несколько раз подряд:

    file.write("Hello1")
    file. write("Hello2")
    file.write("Hello3")

Смотрите, у нас в файле появились эти строчки друг за другом. То есть, здесь как и со считыванием: объект file записывает информацию, начиная с текущей файловой позиции, и автоматически перемещает ее при выполнении метода write.

Если мы хотим записать эти строчки в файл каждую с новой строки, то в конце каждой пропишем символ переноса строки:

   file.write("Hello1\n")
   file.write("Hello2\n")
   file.write("Hello3\n")

Далее, для дозаписи информации в файл, то есть, записи с сохранением предыдущего содержимого, файл следует открыть в режиме ‘a’:

file = open("out.txt", "a")

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

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

file = open("out.txt", "a+")

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

   file.seek(0)
   print( file.read() )

А вот запись данных всегда осуществляется в конец файла.

Следующий полезный метод для записи информации – это writelines:

file.writelines(["Hello1\n", "Hello2\n"])

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

Чтение и запись в бинарном режиме доступа

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

books = [
("Евгений Онегин", "Пушкин А.С.", 200),
("Муму", "Тургенев И.С.", 250),
("Мастер и Маргарита", "Булгаков М.А.", 500),
("Мертвые души", "Гоголь Н.В.", 190)
]

Откроем файл на запись в бинарном режиме:

file = open("out.bin", "wb")

Далее, для работы с бинарными данными подключим специальный встроенный модуль pickle:

И вызовем него метод dump:

Все, мы сохранили этот объект в файл. Теперь прочитаем эти данные. Откроем файл на чтение в бинарном режиме:

file = open("out.bin", "rb")

и далее вызовем метод load модуля pickle:

Все, теперь переменная bs ссылается на эквивалентный список:

Аналогичным образом можно записывать и считывать сразу несколько объектов. Например, так:

import pickle
 
book1 = ["Евгений Онегин", "Пушкин А. С.", 200]
book2 = ["Муму", "Тургенев И.С.", 250]
book3 = ["Мастер и Маргарита", "Булгаков М.А.", 500]
book4 = ["Мертвые души", "Гоголь Н.В.", 190]
 
try:
    file = open("out.bin", "wb")
 
    try:
        pickle.dump(book1, file)
        pickle.dump(book2, file)
        pickle.dump(book3, file)
        pickle.dump(book4, file)
 
    finally:
        file.close()
 
except FileNotFoundError:
    print("Невозможно открыть файл")

А, затем, считывание в том же порядке:

    file = open("out.bin", "rb")
    b1 = pickle.load(file)
    b2 = pickle.load(file)
    b3 = pickle.load(file)
    b4 = pickle.load(file)
 
    print( b1, b2, b3, b4, sep="\n" )

Вот так в Python выполняется запись и считывание данных из файла.

Задания для самоподготовки

1. Выполните считывание данных из текстового файла через символ и записи прочитанных данных в другой текстовый файл. Прочитывайте так не более 100 символов.

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

3. Пусть имеется словарь:

d = {"house": "дом", "car": "машина",
     "tree": "дерево", "road": "дорога",
     "river": "река"}

Необходимо каждый элемент этого словаря сохранить в бинарном файле как объект. Затем, прочитать этот файл и вывести считанные объекты в консоль.

Работа с файлами в Python.

Чтение, запись и обработка файлов в Python.

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

Дополнительно смотрите:

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


Составление пути к файлу в Unix и Windows в Python.

Различия в оставления пути к файлу в Unix и Windows. При доступе к файлу в операционной системе требуется правильно указать путь к файлу.

Открытие/закрытие файла для чтения/записи в Python.

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

Типы обрабатываемых данных и файлов в Python.

Существуют три типа файлов которые чаще всего обрабатываются на практике. Текстовые файлы. Буферизованные двоичные типы файлов. Необработанный тип файлов Raw.

Способы чтения открытого файла в Python.

Существует несколько методов, которые могут быть вызваны для чтения открытого файла. read(size=-1), readline(size=-1), readlines()

Способы записи в открытый файл в Python.

Как и при чтении файлов, файловые объекты имеют несколько методов, которые полезны для записи в файл. fp.write(string), fp. writelines(sequence)

Одновременное чтение из одного и запись в другой файл в Python.

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

Добавление данных в открытый файл в Python..

Иногда может понадобиться добавить данные в файл или начать запись в конце уже заполненного файла. Это легко сделать, используя символ 'a' для аргумента mode функции open():

Управление указателем чтения/записи в файле в Python.

Краткий обзор методов управления указателем чтения/записи в файле.

Создание менеджера для обработки файла в Python.

У менеджера контекста есть два "магических метода". __enter__() - вызывается при вызове оператора with. __exit__() вызывается при выходе из блока оператора with.

Сохранение словарей в формат JSON в Python.

Для сохранения сложных типов данных в файлы, Python позволяет использовать популярный формат обмена данными, называемый JSON. pickle - это протокол, который позволяет сериализовать произвольно сложные объекты Python.

Встроенные модули для работы с разными форматами в Python.

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

Способы записи в открытый файл в Python.

Запись информации в открытый файл.

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

fp.write(string):
Метод записывает в файл строку. "Строка" может быть сколь угодно большой и уже заранее разделена на подстроки [escape-последовательностью][] новой строки '\n'. То есть этот метод позволяет писать в файл как построчно, так и все сразу.

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

# пишем построчно
>>> text = ['Строка №1', 'Строка №2', 'Строка №3', 'Строка №4', 'Строка №5']
>>> with open('text. txt', 'w') as fp:
...    for line in text:
...           fp.write(line + '\n')

# пишем все сразу
>>> text = ['Строка №1', 'Строка №2', 'Строка №3', 'Строка №4', 'Строка №5']
# объединим список строк в одну строку, в качестве символа
# разделителя используем символ новой строки `'\n'`
>>> write_string = '\n'.join(text)
>>> with open('text.txt', 'w') as fp:
...    fp.write(write_string)

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

fp.writelines(sequence):
Метод записывает в файл последовательность, которая в качестве элементов содержит строки. Метод не добавляет автоматически разделители строк '\n'. Если они требуются, то добавляйте их вручную.

# пишем как есть
>>> text = ['Строка №1', 'Строка №2', 'Строка №3', 'Строка №4', 'Строка №5']
>>> with open('text.txt', 'w') as fw, open('text.txt', 'r') as fr:
. ..     fw.writelines(text)
...     fw.flush()
...     for line in fr:
...         print(line, end='')
... 
# 'Строка №1Строка №2Строка №3Строка №4Строка №5'

# Добавляем разделители строк
>>> text = ['Строка №1', 'Строка №2', 'Строка №3', 'Строка №4', 'Строка №5']
# создадим новый список с теми же строками, к которым 
# в конец добавим символ новой строки `'\n'`
>>> write_list = []
>>> for line in text:
...    write_list.append(line + '\n')
>>> with open('text.txt', 'w') as fw, open('text.txt', 'r') as fr:
...     fw.writelines(write_list)
...     fw.flush()
...     for line in fr:
...         print(line, end='')
... 
# Строка №1
# Строка №2
# Строка №3
# Строка №4
# Строка №5

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

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

Создание, открытие и закрытие файла

Работа с любым текстовым файлом в Python начинается с вызова специальной функции open, которая принимает в качестве параметров путь к объекту на компьютере и режим обработки. Путь к документу можно указать как абсолютный (адрес расположения на жестком диске ПК), так и как относительный (координаты относительно папки проекта). Выбирая нужный режим обработки файла, следует учитывать его назначение (“w” для записи, “r” для чтения данных). Следующий пример показывает простое взаимодействие с текстовым документом.

file = open("test.txt", "w")
file.write("hello world")
file.close()

Как можно заметить, функция open принимает относительный путь файла и открывает его для записи. Если в папке с исходным кодом документа с аналогичным именем и расширением .txt не существует, метод open создает его самостоятельно, после чего открывает для него нужный режим обработки. Выполнив все необходимые действия с переменной file, которая ссылается на реальный файл, следует вручную закрыть его, чтобы избежать потери информации. Данную задачу выполняет метод close, если вызвать его при помощи оператора доступа (точки).

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

with open("test.txt", "w") as file:
    file.write("hello world")

Оба примера небольших программ демонстрируют работу с test.txt, который генерируется в каталоге с исходным кодом. В качестве режима обработки для него выбирается запись данных. После этого при помощи метода write в него заносится строка “hello world”. Завершается код в обоих случаях закрытием текстового файла test.txt методом close или автоматически.

Запись построчно

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

В Python запись в файл построчно осуществляется с помощью записи нужной строки с последующей записью символа перевода строки ‘\n’. Рассмотрим пример записи списка поэлементно. Каждый элемент будет записан в новой строке:

lines = ["first", "second", "third"]
with open(r"D:\test.txt", "w") as file:
    for  line in lines:
        file.write(line + '\n')

Приведенный выше пример небольшой программы показывает создание небольшого массива lines, который содержит три строковых элемента: “first”, “second” и “third”. За счет функции open и связки операторов with as происходит открытие текстового файла test.txt в корневом каталоге жесткого диска D. В цикле мы проходим по всем элементам списка и с помощью команды write их записываем. Чтобы каждая запись была с новой строки, добавляем символ перевода строки.

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

lines = ["first", "second", "third"]
with open(r"D:\test.txt", "w") as file:
    file.writelines("%s\n" % line for line in lines)

Этот пример отличается от предыдущего тем, что вызывается метод writelines, который принимает в качестве аргумента генератор. Для разделения элементов последовательности тут применяется “\n”, благодаря чему каждое слово в документе будет находиться в отдельной строке.

Чтение построчно

Прочитать содержимое текстового файла построчно в языке Python очень просто, поскольку в этом прекрасно помогает цикл for. Но для начала все же необходимо открыть документ, как и в предыдущем случае, при помощи open и with as. Однако на этот раз следует указать другой режим обработки файла, выбрав для него “r” для получения доступа к чтению данных.

with open(r"D:\test.txt", "r") as file:
    for line in file:
        print(line)

В этом примере показывается открытие файла test. txt, в котором уже содержится небольшой массив строк, записанный ранее. Построчное чтение информации из файла производится в цикле for. Каждая итерация выводит сведения из новой строки (line) при помощи функции print. Все элементы отображаются на экране построчно, как и были ранее помещены в test.txt.

Количество строк

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

count = 0
with open(r"D:\test.txt", "r") as file:
    for line in file:
        count += 1
        print(count)

Приведенный выше пример демонстрирует работу счетчика count. Для взаимодействия с ним следует открыть текстовый файл в режиме чтения, а затем инкрементировать в каждом новом шаге цикла for объявленную ранее числовую переменную, которая затем выводится в print.

Можно поступить и другим способом. Прочитать файл в список с помощью readlines. А после этого с помощью функции len определить размер списка. Это и будет количество строк.

with open(r"D:\test.txt", "r") as file:
    print(len(file.readlines()))

Поиск строки

Чтобы с помощью Python найти строку в текстовом файле, стоит прибегнуть к помощи встроенного метода readlines, который позволяет автоматически считывать внутреннее содержимое файла. Как и раньше, для начала необходимо открыть test.txt для чтения, чтобы затем поместить данные из него в специальный массив lines. Встроенный метод index позволяет найти номер элемента в последовательности, просто передав ему нужный объект, например, строку “second”.

with open(r"D:\test.txt", "r") as file:
    lines = file.readlines()
    print(lines.index("second\n"))

Поскольку в test.txt все элементы располагаются в отдельных строках, к строке, которую стоит передать методу index в качестве аргумента, необходимо прибавить конструкцию “\n”.

Удаление строки

Чтобы в Python удалить ненужную строку из файла, следует воспользоваться сразу двумя режимами обработки файлов: чтение и запись. Для начала необходимо открыть test.txt для чтения, чтобы поместить информацию из него в отдельный массив lines. Далее потребуется удалить один из элементов последовательности при помощи оператора del, указав ему индекс нужной строки в квадратных скобках. Массив объектов, который получился в итоге, необходимо поместить в исходный текстовый файл, однако на этот раз открыть его надо в режиме записи.

with open(r"D:\test.txt", "r") as file:
    lines = file.readlines()
del lines[1]
with open(r"D:\test.txt", "w") as file:
    file.writelines(lines)

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

Обратите внимание, что в приведенном примере удалится вторая строка, так как индексы списка считаются от нулевого элемента.

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

копирование файлов и удаление или переименование — Проверка существования и получение размера файла

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

Проверка существования файла

Избежать досадных ошибок при работе с текстовым документом, которые могут быть связаны с его отсутствием на жестком диске компьютера, поможет метод exists из модуля os. Его вызов позволяет проверить в Python существование файла по указанному пути, получив в качестве результирующего ответа булево значение True или False. Чтобы воспользоваться данным методом, необходимо прежде всего подключить библиотеку os, а затем вызвать exists у класса path. Следующий пример на Python показывает проверку наличия файлов test.txt и test10.txt в корневом каталоге жесткого диска D. Функция print показывает, что в наличии на D только первый документ.

import os
print(os.path.exists("D:\\test.txt"))
print(os.path.exists("D:\\test10.txt"))

True
False

Иногда при работе с документами возникает потребность в проверке не только существования некоего объекта по заданному пути. Функция isfile из уже упомянутой здесь библиотеки os дает программисту возможность убедиться в том, что полученный по определенному адресу объект на жестком диске компьютера является файлом, а не папкой. Данный метод также  находится в классе path. В следующем примере показывается реакция isfile на получение в качестве аргумента файла test. txt и каталога folder в корне D. Как видно из результатов работы функции print, в первом случае отображается True, а затем False.

import os
print(os.path.isfile("D:\\test.txt"))
print(os.path.isfile("D:\\folder"))

True
False

Проверить наличие файла по указанному адресу можно и с помощью функции open, применив дополнительно конструкцию with as. Данный метод производит открытие документа для того, чтобы программа могла взаимодействовать с его содержимым. Если функция open смогла без ошибок выполниться, это означает, что по переданному ей в качестве аргумента пути имеется файл. Если же произойдет исключение, то файл не удалось открыть. Это еще не говорит о том, что его нету. Возможно, к примеру, не достаточно прав доступа к нему. В приведенном ниже примере программа сообщает о наличии искомого документа при помощи метода print. Как видно из результатов, на экран выводится сообщение file is open.

try:
    with open("D:\\test.txt") as file:
        print("file is open")
except:
    print('no open')

file is open

Копирование файла

Библиотека под названием shutil включает в себя несколько полезных функций для создания копий объектов на жестком диске. Чтобы быстро скопировать файл в исходный каталог, стоит воспользоваться методом copyfile, предварительно подключив модуль shutil. В роли первого аргумента здесь выступает оригинальный документ, в то время как вторым параметром нужно поставить предполагаемый новый файл. Стоит учитывать, что копируется только содержимое, но не метаданные. В следующем примере происходит копирование данных из файла test.txt в test2.txt на диске D. Функция copyfile также возвращает адрес созданного документа.

import shutil
shutil.copyfile("D:\\test.txt", "D:\\test2.txt")

Встроенный метод copy из модуля shutil позволяет в Python копировать файл в указанную папку, сохраняя при этом его изначальное имя. Приведенный ниже пример кода демонстрирует копирование информации из test.txt в объект, который находится на диске D в каталоге под названием folder. Как и в предыдущем случае с функцией copyfile, переносятся только внутренние данные, но не сведения о дате создания и редактирования документа.

import shutil
shutil.copy("D:\\test.txt", "D:\\folder")

Чтобы полностью скопировать информацию из текстового файла, а также все сведения о нем, необходимо воспользоваться готовым методом copy2. Способ его применения такой же, как и в случае с функцией copy. На месте первого параметра здесь размещается адрес изначального файла, в то время как второй аргумент сообщает локацию и название нового документа. Ниже показан пример, где содержимое и метаданные копируются в test2.txt из папки folder.

import shutil
shutil.copy2("D:\\test.txt", "D:\\folder\\test2.txt")

Удаление файла

Избавиться от объекта, если известно его имя и точное расположение на диске, очень легко. С этой задачей поможет справиться метод remove из уже упомянутой ранее библиотеки os. Все, что требуется сделать, это передать ей в качестве параметра полный адрес ненужного файла, не забыв для начала подключить модуль os. Ниже приведен пример того, как с помощью скрипта Python удалить файл test. txt в корне диска D.

import os
os.remove("D:\\test.txt")

Получение размера файла

Определить точный размер любого объекта на жестком диске можно с помощью стандартной функции getsize из модуля os, которая возвращает величину файла в байтах. Выполнив импорт библиотеки os, необходимо вызвать метод класса path. Аргументом тут выступает расположение документа в памяти компьютера. Согласно результатам выполнения getsize, размер test.txt составляет 7289. Метод print выводит это на экран.

import os
print(os.path.getsize("D:\\test.txt"))

7289

Вычислить размер файла в Python можно и другим способом, открыв его при помощи open, после чего вызвав функцию seek. Ей необходимо передать в качестве параметра область для чтения данных, начиная от начала файла до его конца. В итоге следует вызвать метод tell через ссылку на текстовый файл, а затем отправить результат его работы в print для вывода в консоль.

import os
with open("D:\\test. txt") as file:
    file.seek(0, os.SEEK_END)
    print(file.tell())

7289

Переименование файла

Изменить название документа можно не только благодаря средствам системы, но и с помощью готовых функций модуля os. С этой задачей хорошо справляется метод rename, принимающий в качестве параметров исходное и новое имя файла. Следующий пример показывает работу с документом test.txt в корневом каталоге диска D, который переименовывается в test1.txt.

import os
os.rename("D:\\test.txt", "D:\\test1.txt")

Аналогично, можно в Python переименовать файл с помощью метода move из модуля shutil. Подключив данную библиотеку, достаточно лишь передать функции местоположение и новое имя документа. Код программы, где продемонстрировано переименование test.txt в test1.txt, находится ниже.

import shutil
shutil.move("D:\\test.txt", "D:\\test1.txt")

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

7. Ввод и вывод - документация Python 3.6.12

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

7.1. Более простое форматирование вывода

До сих пор мы встречали два способа записи значений: операторов выражения и функция print () . (Третий способ - использовать метод write () файловых объектов; на стандартный выходной файл можно ссылаться как на sys.stdout . Дополнительную информацию см. В Справочнике по библиотеке.)

Часто требуется больше контроля над форматированием вывода, чем просто печать значений, разделенных пробелами. Есть два способа отформатировать ваш вывод; в первый способ - выполнить всю обработку строк самостоятельно; используя нарезку строк и операции конкатенации вы можете создать любой макет, который вы можете себе представить. В строковый тип имеет несколько методов, которые выполняют полезные операции для заполнения строки с заданной шириной столбца; они будут обсуждаться в ближайшее время.Секунда способ - использовать форматированные строковые литералы или str.format () метод.

Модуль string содержит класс Template , который предлагает еще один способ подставить значения в строки.

Конечно, остается один вопрос: как преобразовать значения в строки? К счастью, У Python есть способы преобразовать любое значение в строку: передать его repr () или str () функций.

Функция str () предназначена для возврата представлений значений, которые довольно удобочитаемый, а repr () предназначен для генерации представлений который может быть прочитан интерпретатором (или вызовет SyntaxError , если нет эквивалентного синтаксиса).Для объектов, не имеющих особого представление для человеческого потребления, str () вернет то же значение, что и репр () . Многие значения, такие как числа или структуры, такие как списки и словари имеют одинаковое представление с использованием любой функции. Струны, в в частности, имеют два различных представления.

Некоторые примеры:

Ввод-вывод файла Python - запись в файл Python и файл чтения Python

1. Ввод-вывод файла Python и чтение и запись файла

Важным компонентом операционной системы являются ее файл и каталоги.Мы говорили о каталогах Python . Благодаря этому мы научились управлять каталогами (создавать, переименовывать, удалять ...). Сегодня мы поговорим о файловом вводе-выводе Python . После этого урока вы сможете открыть файл Python, закрыть файл Python, прочитать файл Python и записать в файл Python. Давай начнем.

Ввод-вывод файла Python - Введение

2. Что такое файл Python?

Файл - это место на диске, в котором хранится соответствующая информация и которому присвоено имя. Жесткий диск энергонезависим, и мы используем файлы для организации наших данных в разных каталогах на жестком диске. RAM (оперативная память) энергозависима; он хранит данные только до тех пор, пока они активны. Итак, мы используем файлы для постоянного хранения данных. Чтобы читать или писать в файл, мы должны сначала открыть его. А когда мы закончим с ним, мы должны закрыть его, чтобы освободить ресурсы, которые он хранит (Открыть, Чтение / Запись, Закрыть).

3. Python Open File

Чтобы запустить ввод-вывод файлов Python, мы имеем дело с файлами и имеем несколько встроенных функций , методов и в Python . Чтобы открыть файл в Python, мы используем метод read ().

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

 >>> импорт ОС
>>> os.getcwd () 

'C: \\ Users \\ lifei \\ AppData \\ Local \\ Programs \\ Python \\ Python36-32'

 >>> os.chdir ('C: \ \ Users \\ lifei \\ Desktop ')
>>> os.listdir () 

['Adobe Photoshop CS2.lnk', 'Atom.lnk', 'Резервное копирование iPhone7 + 20-1-18', 'Burn Book. txt', 'ch', 'desktop.ini ',' dmkidnap.png ',' Документы ',' Eclipse Cpp Oxygen.lnk ',' Eclipse Java Oxygen.lnk ',' Eclipse Jee Oxygen.lnk ',' gift.jpg ',' Items for trip.txt ',' Major temp ', structure', 'office temp.jpg', 'Papers', 'Remember to Remember.txt ',' To do.txt ',' Today.txt ']
Если это кажется вам в новинку, обязательно ознакомьтесь с Python Directory .
Теперь давайте откроем файл Python «To do.txt».

 >>> open ('To do.txt') 

<_io.TextIOWrapper name = 'To do.txt' mode = 'r' encoding = 'cp1252'>

Но чтобы работать с этим, мы должны сохранить это в переменную Python .Давай сделаем это.

 >>> todo = open ('To do.txt')
>>> todo 

<_io.TextIOWrapper name = 'To do.txt' mode = 'r' encoding = 'cp1252 ′>

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

Перейдите по этой ссылке, чтобы узнать больше о функциях Python

Python File I / O - Python Open File

a. Режимы файлов Python

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

Режим Описание
r Для чтения файла (по умолчанию)
w Для записи файла; Создает новый файл, если он не существует, обрезает, если он есть
x Исключительное создание; сбой, если файл уже существует
a Чтобы добавить в конец файла; создать, если не существует
t Текстовый режим (по умолчанию)
b Двоичный режим
+ Чтобы открыть файл для обновления (чтение или запись)

Возьмем пару примеров.

 >>> todo = open ('To do.txt', 'r + b') # Читать и писать в двоичном режиме
>>> todo = open ('To do.txt', 'a') 

b. Выбор кодировки

Кроме того, рекомендуется указывать, какую кодировку мы хотим, потому что разные системы используют разные кодировки. В то время как Windows использует «cp1252», Linux использует «utf-8».

 >>> todo = open ('To do.txt', mode = 'r', encoding = 'utf-8') 

c. Когда файл Python не существует

Наконец, если вы попытаетесь открыть файл Python, который не существует, интерпретатор выдаст FileNotFoundError.

 >>> todo = open ('abc.txt') 

Traceback (последний вызов последним):

Файл «», строка 1, в

todo = open (' abc.txt ')

FileNotFoundError: [Errno 2] Нет такого файла или каталога:' abc.txt '

Расскажите, как вам Python Описание открытого файла.

4. Python Close File

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

 >>> todo.close () 

Python File I / O - Python Close File

a. Попробуйте ... наконец, в Python

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

 >>> попробуйте:
f = open ('To do.txt')
print («До»)
печать (1/0)
Ну наконец то:
f.close () 

До

Traceback (последний вызов последний):

Файл «», строка 4, в

print (1/0)

ZeroDivisionError: деление на ноль

Перейдите по этой ссылке, чтобы обработать исключение в Python

b. С

Если вы считаете, что необходимость помещать close () каждый раз, когда вы заканчиваете работу с файлом Python, неуместна, используйте оператор «with».

 >>> с open ('To do.txt') как f:
        f.read () 

«Получить продукты \ nОрганизовать комнату \ nПечать этикеток \ nНаписать статью \ nИзучать для экзамена»
При этом он неявно закроет файл, как только закончит выполнение операторов под блоком.

5. Файл чтения Python

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

Ввод-вывод файла Python - Файл чтения Python

a. Метод read ()

Мы можем использовать метод read () для чтения содержимого файла Python.

 >>> with open ('Сделать.txt ') в качестве задачи:
          todo.read () 

'Получить продукты \ nОрганизовать комнату \ nПечать этикеток \ nНаписать статью \ nУчиться к экзаменуНаучиться готовить \ nНаучиться готовить'
Когда мы предоставляем целочисленный аргумент для read (), он читает такое количество символов с самого начала файла Python.

 >>> todo = open ('To do.txt')
>>> todo.read (5) 

‘Get g’
Теперь, когда мы вызываем read () без каких-либо аргументов, он читает остальную часть файла Python.

 >>> todo.read () 

‘roceries \ nОрганизовать комнату \ nПечать этикеток \ nНаписать статью \ nУчиться к экзаменуНаучиться готовить \ nНаучиться готовить”
Обратите внимание, что он печатает "\ n" для новой строки.И когда мы его еще читаем, он печатает пустую строку, потому что курсор достиг конца файла Python.

 >>> todo. read ()
''
>>> todo.close () 

б. Seek () и tell ()

Ладно, шутки между собой, эти два метода позволяют нам перемещать курсор и находить его положение. tell () сообщает нам, где находится курсор.

 >>> todo = open ('To do.txt')
>>> todo.read (5) 

‘Get g’

 >>> todo.tell () 

5
seek () принимает целочисленный аргумент и помещает курсор после этого количества символов в файле Python.Наряду с этим он возвращает новую позицию курсора.

 >>> todo.seek (0) 
 >>> todo.read () 

'Получить продукты \ nОрганизовать комнату \ nПечать этикеток \ nНаписать статью \ nУчиться к экзаменуНаучиться готовить \ nНаучиться готовить'
seek () и tell () похожи на seekg (), seekp (), tellg () и tellp () в C ++.

г. Использование цикла for Python

Мы можем просто использовать цикл for для итерации по файлу. В этом прелесть Python - он все упрощает.

 >>> для открытой строки ('To do. txt'):
           print (line, end = '') 

Получить продукты
Организовать комнату
Распечатать этикетки
Написать статью
Учеба для экзамена
Научиться готовить
Мы использовали параметр «end», чтобы интерпретатор не добавлял лишние символы новой строки в каждый вывод. В противном случае результат выглядел бы так:

 >>> для строки in open ('To do.txt'):
         print (line) 

Купите продукты
Организуйте комнату
Распечатайте этикетки
Напишите статью
Подготовка к экзамену
Научитесь готовить

d.Readline ()

В качестве альтернативы метод readline () позволяет нам читать по одной строке за раз. Проще говоря, интерпретатор останавливается после каждого «\ n».

 >>> todo = open ('To do.txt')
>>> todo.readline () 

'Получите продукты \ n'

 >>> todo.readline () 

'Организуйте комнату \ n'

 >>> todo.readline () 

'Распечатать этикетки \ n '

 >>> todo. readline () 

' Написать статью \ n '

 >>> todo.readline () 

'Подготовьтесь к экзамену \ n'

 >>> todo.readline () 

'Научитесь готовить'

 >>> todo.readline () 

 >>> todo.readline () 

e. Readlines ()

Наконец, метод readlines () считывает остальные строки / файл.

 >>> todo.seek (0) 
 >>> todo.read (5) 

'Get g'

 >>> todo.readlines () 

['Продовольственные товары \ n', 'Организовать комнату \ n ',' Распечатать этикетки \ n ',' Написать статью \ n ',' Подготовиться к экзамену \ n ',' Научиться готовить ']

6.Python Запись в файл

Чтобы записать файл Python, мы используем метод write ().

 >>> todo = open ('To do.txt')
>>> todo.write ("HI") 

Traceback (последний вызов последний):

Файл «», строка 1, в

todo.write («HI»)

io.UnsupportedOperation: не доступен для записи

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

 >>> todo = open ('To do.txt', 'a')
>>> todo.write ('\ nНаучитесь готовить') 

14

 >>> todo.close () 

Когда мы проверили файл (обновили его), мы обнаружили:
Купить продукты
Организовать комнату
Распечатать этикетки
Написать статью
Подготовьтесь к экзамену
Научитесь готовить
В заключение, вы можете использовать «w», «a» или «x». Буква «w» стирает содержимое и перезаписывает его. Так что будьте осторожны с этим. Кроме того, write () вернул здесь 14 символов, потому что он добавил 14 символов в файл Python.
Но вы не сможете прочитать файл Python, если откроете его в режиме «a».

 >>> todo = open ('To do.txt', 'a')
>>> todo.read () 

Traceback (последний вызов последний):

Файл «», строка 1, в

todo.read ()

io.UnsupportedOperation: not читаемый

Чтобы обойти это, вам нужно использовать 'a + r'.

Итак, это все о Python File I / O Tutorial. Надеюсь, вам понравится наше объяснение.

7. Заключение

В этом руководстве по вводу / выводу файлов Python мы увидели несколько функций Python и методов , таких как read (), write (), readline (), readlines (), seek () и tell ( ).Теперь вы можете управлять файлами на элементарном уровне. Давай, тренируйся, а завтра возвращайся снова. Кроме того, если у вас возникнут какие-либо вопросы, не стесняйтесь спрашивать в разделе комментариев.
См. Также - Функция диапазона и Аргументы функции Python
Для справки

Python - чтение текстового файла

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

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

  1. Вызов встроенной функции open () с указанием пути к файлу и режима в качестве аргументов.Функция open () возвращает файловый объект.
  2. Вызвать метод read () для файлового объекта. read () возвращает строку.
  3. Возвращенная строка - это полный текст из текстового файла.

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

В следующей программе Python мы откроем файл sample.txt в режиме чтения. Мы прочитаем все содержимое текстового файла и выведем текст на консоль.

Программа Python

  fileObject = open ("sample.txt "," r ")
data = fileObject.read ()
print (data)  

Выходные данные

  Добро пожаловать на pythonexamples.org  

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

Пример 2: только чтение некоторых символов в текстовом файле

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

В следующей программе Python мы прочитаем первые 20 символов файла.

Программа Python

  f = open ("sample.txt", "r")
data = f.read (20)
print (data)  

Вывод

  Добро пожаловать в pythonexa  

Функция read (20) вернула первые 20 символов из текстового файла.

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

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

В следующем примере мы явно откроем файл в текстовом режиме, указав «t» вместе с режимом чтения «r» .

Программа Python

  f = open ("sample.txt", "rt")
data = f.read ()
print (data)  

Выходные данные

  Добро пожаловать на pythonexamples.org  

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

Чтобы прочитать текст построчно из файла, используйте File. readline () функция. File.readline () возвращает текущую строку и обновляет свой указатель на следующую строку. Итак, когда вы вызываете функцию readline () в следующий раз, возвращается следующая строка.

Помните, что readline () возвращает строку вместе с символом новой строки в конце строки, за исключением последней строки. Итак, если вам не нужен символ новой строки, вы можете использовать функцию strip (). Здесь есть одна загвоздка. Если ваша строка содержит символы пробела в начале и в конце, и если вы используете strip (), вы потеряете эти символы пробела в строке.

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

Программа Python

  #get file object
f = open ("sample.txt", "r")

в то время как (Истина):
# читать следующую строку
line = f.readline ()
# если строка пуста, вы закончили со всеми строками в файле
если не строка:
сломать
# вы можете получить доступ к строке
печать (line.strip ())

#close file
f.close  

Выход

  Привет, пользователь!
Добро пожаловать в примеры Python. 
Продолжайте изучение. 

Резюме

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

3 способа записи текста в файл в Python

Если вас интересует запись текста в файл на Python, вероятно, есть много способов сделать это. Вот три способа записать текст в выходной файл в Python. Первым шагом при записи в файл является создание файлового объекта с помощью встроенной команды Python «open».Чтобы создать и записать в новый файл, используйте опцию «открыть» с «w». Опция «w» удалит любой предыдущий существующий файл и создаст новый файл для записи.

# открыть (новый) файл для записи
outF = open ("myOutFile.txt", "w")
 

Если вы хотите добавить к существующему файлу, используйте оператор open с опцией «a». В режиме добавления Python создаст файл, если он не существует.

# открыть файл для добавления
outF = open ("myOutFile. txt", "a")
 

После того, как вы создали файловый объект в режиме записи / добавления, вы можете писать текст несколькими способами.Допустим, у нас есть текст, который мы хотим написать, в списке «textList».

textList = ["Один", "Два", "Три", "Четыре", "Пять"]
 

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

Запись в файл по одной строке за раз с помощью функции write ()

Давайте создадим новый файл, создав файловый объект «outF», используя параметр «w», как и раньше. Чтобы писать построчно, мы перебираем текстовый список, получаем каждый элемент и записываем его в файл.

outF = open ("myOutFile.txt", "w")
для строки в textList:
  # записываем строку в выходной файл
  outF.write (строка)
  outF.write ("\ п")
outF.close ()
 

Обратите внимание, что элементы в «textList» не имеют символа новой строки «\ n». Поэтому мы добавили это при записи в файл. В противном случае все пять элементов будут в одной строке выходного файла. Также обратите внимание на outF.close () в конце. close () закрывает доступ к файлу. Рекомендуется использовать метод close () для закрытия файла после того, как мы закончили работу с файлом.

Запись в файл по одной строке за раз с помощью функции print

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

outF = open ("myOutFile.txt", "w")
для строки в textList:
  печать >> outF, строка
outF.close ()
 

Writelines (): запись всех строк в файл одновременно в Python

python Writelines для записи всех строк

Python также имеет метод, который может записывать все строки одновременно в файл.Метод Python «writelines () »принимает список строк в качестве входных данных и записывает в объект файла, открытый с доступом на запись / добавление. Например, чтобы написать наш список всех строк «all_lines», используя «Writelines ().

outF = open ("myOutFile.txt", "w")
outF.writelines (all_lines)
outF.close ()
 

Мы также можем упростить себе жизнь, не написав оператор file.close (), используя оператор with для записи в файл. Например,

с open (out_filename, 'w') как out_file:
     ..
     ..
     .. parsed_line
     out_file.write (строка_собранного)
 

Если вас интересует чтение из текстового файла, отметьте «Три способа чтения текстового файла построчно в python».

.
Оставить комментарий

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *