Каталог расширений

Популярные теги

3gp       avi       fb2       jpg       mp3       pdf      

Главная » Разное » Как открыть последний созданный файл python

Как открыть последний созданный файл python


Файлы. Работа с файлами. | Python 3 для начинающих и чайников

В данной статье мы рассмотрим встроенные средства python для работы с файлами: открытие / закрытие, чтение и запись.

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

f = open('text.txt', 'r')

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

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

Режимы могут быть объединены, то есть, к примеру, 'rb' - чтение в двоичном режиме. По умолчанию режим равен 'rt'.

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

Чтение из файла

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

Первый - метод read, читающий весь файл целиком, если был вызван без аргументов, и n символов, если был вызван с аргументом (целым числом n).

 >>> f = open('text.txt') >>> f.read(1) 'H' >>> f.read() 'ello world!\nThe end.\n\n'

Ещё один способ сделать это - прочитать файл построчно, воспользовавшись циклом for:

 >>> f = open('text.txt') >>> for line in f: ... line ... 'Hello world!\n' '\n' 'The end.\n' '\n'

Запись в файл

Теперь рассмотрим запись в файл. Попробуем записать в файл вот такой вот список:

 >>> l = [str(i)+str(i-1) for i in range(20)] >>> l ['0-1', '10', '21', '32', '43', '54', '65', '76', '87', '98', '109', '1110', '1211', '1312', '1413', '1514', '1615', '1716', '1817', '1918']

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

 >>> f = open('text.txt', 'w')

Запись в файл осуществляется с помощью метода write:

 >>> for index in l: ... f.write(index + '\n') ... 4 3 3 3 3

Для тех, кто не понял, что это за цифры, поясню: метод write возвращает число записанных символов.

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

 >>> f.close()

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

 >>> f = open('text.txt', 'r') >>> l = [line.strip() for line in f] >>> l ['0-1', '10', '21', '32', '43', '54', '65', '76', '87', '98', '109', '1110', '1211', '1312', '1413', '1514', '1615', '1716', '1817', '1918'] >>> f.close()

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

запись и чтение после создания или открытия файла

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

Создание и открытие

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

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

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

Если же файл с указанным именем test.txt уже существует в каталоге с кодом, программа просто продолжит работу с ним, не создавая новый документ. Как можно заметить, имя файла является первым параметром метода open. Сразу за ним следует специальная буква, которая обозначает метод обработки данных. В данном случае “w” означает write, то есть запись. Подробнее обо всех доступных режимах работы будет немного дальше, а сейчас важно усвоить, что после выполнения любых манипуляций над файлом, его обязательно следует закрыть с помощью функции close, чтобы гарантированно избежать потери информации.

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

file = open(r"D:\test.txt", "w")
 file.close()

Перед строковым литералом мы использовали символ r, для отключения экранирования. Иначе компилятор посчитает последовательность “\t” как символ табуляции и выдаст исключение.

Режим открытия

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

Символ Значение
“r” открытие для чтения (по умолчанию)
“w” открытие для записи, а если его не существует по заданному пути, то создается новый
“x” открытие для записи, но только если его еще не существует, иначе будет выдано исключение
“a” открытие на дополнительную запись, чтобы информация добавлялась в конец документа
“b” открытие в двоичном режиме
“t” открытие в текстовом режиме (по умолчанию)
“+” открытие одновременно на чтение и запись

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

Еще один пример: отличие “r+” и “w+” заключается в том, что во втором случае создастся новый файл, если такого нет. В первом же случае возникнет исключение. При использовании “r+” и “w+” файл будет открыт и на чтение и на запись. Пример обработки исключения разберем, когда будем рассматривать чтение файла.

Методы

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

Свойство Значение
name возвращает имя файла
mode возвращает режим, в котором был открыт
closed возвращает true, если файл закрыт и true, если открыт
softspace возвращает true, если при выводе данных из файла не следует отдельно добавлять символ пробела

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

Например:

f = open(r"D:\test.txt", "w")
 print(f.name)
 f.close()
 
 D:\test.txt

Запись

В Python 3 запись в файл осуществляется с помощью метода write. Метод вызываем у объекта, который ссылается на существующий файл. Важно помнить, что для этого следует предварительно открыть документ с помощью функции open и указать режим записи символом “w”. Метод write принимает в качестве аргумента данные, которые нужно поместить в текстовый файл. Следующий пример кода показывает запись строки “hello”.

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

Если необходимо добавить новую информацию к записанным ранее данным, следует заново вызвать функцию open, указав ей в качестве режима работы символ “a”. В противном случае все сведения из файла test.txt будут полностью удалены. В приведенном ниже примере кода текстовый документ открывается для дополнительной записи, после чего в него помещается строковый литерал “ world” с пробелом вначале. Таким образом в test.txt будет располагаться “hello world”. После всего этого не нужно забывать об обязательном закрытии файла.

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

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

Запись бинарных данных

При записи бинарных данных, следует использовать режим “wb”. Вот пример записи строки в кодировке utf8:

f = open('test.dat', 'wb')
 f.write(bytes('строка', 'utf8'))
 f.close()

Чтение

Для чтения информации из файла в Python 3, следует вызывать метод read через объект, который ссылается на существующий документ. Также необходимо не забывать указывать “r” в качестве второго параметра функции open при открытии текстового файла.

В следующем примере read возвращает информацию из test.txt в метод print, который затем выводит сведения на экран. Как и прежде, программа завершается закрытием документа при помощи метода close. Метод read также может принимать целочисленный параметр, который используется для передачи количества символов для чтения. К примеру, введя 5, программа прочитает только hello.

try:
 file = open("test.txt", "r")
 print(file.read())
 file.close()
 except FileNotFoundError:
 print('Not found')
 except IOError:
 print('Something else')

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

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

Чтение бинарных данных

В случае, если данные бинарного вида — следует использовать “rb” в функции open. Рассмотрим пример:

try:
 f = open("test.dat", "rb")
 b = f.read(1)
 str = ""
 while True:
 b = f.read(1)
 if b == b'':
 break
 str += b.hex()
 print(str)
 f.close()
 except IOError:
 print('error')
 
 81d182d180d0bed0bad0b0

Здесь побайтно читается файл. Каждый байт приводит к строковому виду в шестнадцатеричном представлении. С помощью функции print выводится результирующая строка.

with as

Чтобы немного автоматизировать обработку текстовых файлов, рекомендуется использовать связку операторов with as. Благодаря им пропадает необходимость в вызове метода close для документа, который необходимо закрыть, поскольку это происходит автоматически. Все это демонстрируется в следующем фрагменте кода, где происходит считывание данных из test.txt. Как обычно, метод print используется для вывода строковой информации на экран.

with open('test.txt', 'r') as file:
 print(file.read())

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

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

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

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

>>> fp = open('filename', 'w')

Первый аргумент filename - это строка, содержащая имя файла. Второй аргумент mode - это другая строка, содержащая несколько символов, описывающих способ использования файла. режим может быть, 'r' когда файл будет только читаться, 'w' только для записи (существующий файл с таким же именем будет удален) и 'a' открывается файл для добавления, любые данные, записанные в файл, автоматически добавляются в конец. Режим 'r+' открывает файл для чтения и записи. Аргумент mode является необязательным. По умолчанию будет предполагаться, что файл открыт на чтение, если mode опущен.

Обычно файлы открываются в текстовом режиме, то есть вы читаете и пишете строки из файла и в файл, которые закодированы в определенной кодировке. Если кодировка не указана, по умолчанию используется кодировка платформы (смотрите описание встроенной функции open()). При добавлении в аргумент mode литерала 'b' файл открывается в двоичном режиме. Теперь данные читаются и записываются в виде байтовых объектов. Этот режим следует использовать для всех файлов, которые не содержат текст.

В текстовом режиме, используемом по умолчанию, при чтении файла выполняется преобразование концовок строк, эти преобразования зависят от платформы. Символы конца строки \n в Unix, \r\n в Windows, в значение \n. При записи файла записи в текстовом режиме по умолчанию выполняется преобразование вхождений \n обратно в концовки строк, соответствующие платформам. Эта закулисная модификация данных подходит для текстовых файлов, но будет повреждать двоичные данные, такие как файлы JPEG или EXE. Будьте очень осторожны, используя двоичный режим при чтении и записи таких файлов.

Рекомендуется использовать контекстный менеджер with при работе с файловыми объектами. Преимущество заключается в том, что файл правильно закрывается после завершения, даже если в какой-то момент возникает исключение. Использование with также намного короче, чем писать эквивалентные try-finally блоки:

>>> with open('filename') as fp: ... read_data = fp.read() # Мы можем проверить, что файл был автоматически закрыт. >>> fp.closed # True

Если вы не используете ключевое слово with, то вам следует вызвать fp.close(), чтобы закрыть файл и немедленно освободить все системные ресурсы, используемые им. Если вы явно не закроете файл, сборщик мусора Python в конечном итоге уничтожит объект и закроет открытый файл для вас, но файл может оставаться открытым некоторое время. Другой риск заключается в том, что не закрытый файл может привести к нежелательному поведению, включая утечку ресурсов. Так что лучше всего убедиться, что ваш код ведет себя определенным образом, что уменьшает риск нежелательного поведения.

Правильный способ закрыть файл не используя инструкцию with это использовать блок try-finally:

>>> fp = open('filename') >>> try: ... # Дальнейшая обработка файлов идет здесь ... read_data = fp.read() >>> finally: ... fp.close()

После закрытия объекта file object с помощью оператора with или вызова функции fp.close() в блоке try-finally попытки использовать объект file автоматически завершатся неудачей.

>>> fp.close() >>> fp.read() # Traceback (most recent call last): # File "<stdin>", line 1, in <module> # ValueError: I/O operation on closed file.

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

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

Чтобы не соскучится, мы покажем несколько способов внесения данных в файл и наглядно увидим результат. Чтобы открыть файл для записи или же создать его, мы воспользуемся функцией open(filename, mod) и в качестве второго параметрам mod укажем значение w т.е. (write) запись. Если файл с указанным названием filename не существует - он будет создан.

Создаем новый файл в Python

# -*- coding: utf-8 -*- my_file = open('snake.txt', 'w') # Закрываем файл my_file.close()

После выполнения данного скрипта, по указанному нами пути будет создан новый файл snake.txt если файл не был создан то нужно проверить права доступа на папку. Стоит учесть, что если файл snake.txt существовал ранее, то после открытия его функцией open() и мод W, тогда содержимое файла удаляется. Если вы хотите добавить что-то в конце, то следует использовать мод 'a+'.

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

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

# -*- coding: utf-8 -*- my_file = open('snake.txt', 'w') text_for_file = 'Some text here...' my_file.write(text_for_file) my_file.close()

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

Заменяем данные из определенной строки файла

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

Изначальный файл snake.txt

Я Программа написанная в Python 3

Заменяем 5-ю строку со значением 'Python' на значение 'Питон'

# -*- coding: utf-8 -*- # Открываем файл только для чтения f = open('snake.txt', 'r') lines = f.readlines() lines[4] = 'Питон' + '\n' # Закрываем файл f.close() # Открываем файл для записи save_changes = open('snake.txt', 'w') # Сохраняем список строк save_changes.writelines(lines) # Закрываем файл save_changes.close()

Финальный вид файла snake.txt 

Я Программа написанная в Питон 3

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

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

# -*- coding: utf-8 -*- # Открываем файл только для чтения old_image = open('temp/pro.jpeg', 'r').read() # Создаем новый файл new_image = open('new_pro.jpeg', 'w') # Сохраняем данные старой картинки в новую new_image.write(old_image) new_image.close()

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

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": "река"}

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

Метод open() в Python - примеры открытия файла

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

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

Метод open() открывает определенный файл в указанном режиме и возвращает файловый объект. Затем этот файловый объект можно использовать для выполнения различных операций с файлами. Синтаксис использования метода приведен ниже.

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

где,

  • файл относится к имени или дескриптору файла, а mode — это режим, в котором файл должен быть открыт. Это основные параметры, необходимые для открытия файла.
  • Buffering — необязательное целое число, используемое для установки буферизации. По умолчанию установлено значение (-1),
  • кодировка — это имя кодировки, используемой для декодирования или кодирования файла,
  • errors — это необязательная строка, указывающая, как должны обрабатываться ошибки кодирования и декодирования. Обратите внимание, что это нельзя использовать в двоичном режиме.
  • Новая строка определяет, как работает универсальный режим новой строки (применяется только к текстовому режиму). Это может быть None (по умолчанию), '' , '\n' , '\r' и '\r\n' .
  • closefd указывает, является ли переданный параметр файла именем файла или дескриптором файла. Если упоминается файловый дескриптор, он должен иметь значение False. Или же True (по умолчанию). В противном случае возникнет ошибка,
  • opener — это вызываемый настраиваемый параметр. Указанный файловый дескриптор для файлового объекта получается путем вызова средства opener с помощью (file, flags). opener должен возвращать дескриптор открытого файла (передача os.open качестве opener приводит к функциональности, аналогичной передаче None ).

Режимы открытия для open() в Python

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

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

Пример

Мы собираемся открыть файл с именем file.txt с содержимым (как показано ниже) с помощью метода open() .

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

# opening a file
 f = open('file.txt', 'r') # file object
 
 print("Type of f: ", type(f))
 
 print("File contents:")
 
 for i in f:
 print(i)
 
 f.close() # closing file after successful operation

Выход:

Type of f: <class '_io.TextIOWrapper'>
 File contents:
 Python
 
 Java
 
 Go
 
 C
 
 C++
 
 Kotlin

Здесь мы открыли файл file.txt в режиме только для чтения ( ' r ' ). Метод open() возвращает объект файла в f . Затем мы прошли через этот объект, используя цикл for для доступа к содержимому файла.

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

Открытие нескольких файлов

В Python мы можем открывать два или более файла одновременно, комбинируя оператор with, метод open() и оператор запятой ( ' , ' ). Давайте рассмотрим пример, чтобы лучше понять.

Здесь мы попытались открыть два независимых файла file1.txt и file2.txt и распечатать их соответствующее содержимое.

# opening multiple files
 try:
 with open('file1.txt', 'r+') as a, open('file2.txt', 'r+') as b:
 print("File 1:")
 for i in a:
 print(i)
 print("File 2:")
 for j in b:
 print(j)
 except IOError as e:
 print(f"An Error occured: {e}")
 
 # file closing is not required

Выход:

File 1:
 John Alex Leo Mary Jim
 File 2:
 Sil Rantoff Pard Kim Parsons

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

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

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

Ключевые методы, предоставляемые нам Python для обработки файлов: open () , close () , write () , read () , seek () и append () .

Давайте рассмотрим метод open () , который позволяет нам открывать файлы в Python в разных режимах.

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

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

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

Содержание файла примера открытого файла Python

1. Открытие файла с помощью метода open ()

Чтобы открыть OpenFile.txt и прочитать текстовое содержимое файла, давайте воспользуемся методами open () и read () .

 файл = открытый ('OpenFile.txt') печать (file.read ()) file.close ()

Метод read () прочитает все содержимое файла.

Вывод в открытый файл Python

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

2. Различные режимы для метода open ()

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

 файл = открытый ('OpenFile.txt') печать (file.read ()) file.write («тестовая запись») file.close ()

Мы сохраним операцию чтения как есть, чтобы мы могли видеть, где останавливается код.

Запись файла запрещена, режим только для чтения

Итак, что такое режимы и как их добавить? Ниже приведен список режимов при использовании метода open ().

  • r : режим только для чтения.
  • r +: Режим чтения и записи. Не будет создавать новый файл, и открытие не удастся, если файл не существует
  • rb : двоичный режим только для чтения для чтения изображений, видео и т. Д.
  • w: Режим только записи. Заменяет существующее содержимое файла. Это создаст новый файл, если указанное имя файла не существует.
  • w +: Режим чтения и записи.
  • wb: Двоичный режим только для записи для записи в медиафайлы.
  • wb +: Двоичный режим чтения и записи.
  • a: Режим добавления. Не перезаписывает существующее содержимое.
  • a +: Режим добавления и чтения. Он создаст новый файл, если имя файла не существует.
  • ab: Добавить двоичный режим для изображений, видео и т. Д.
  • ab +: Добавить и прочитать двоичный режим.

3. Открытие файлов в режиме записи в Python

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

 file = open ('OpenFile.txt', 'ш') печать (file.read ()) file.close ()

Добавляя «w» при открытии файла в первой строке, мы указываем, что файл должен быть открыт в режиме записи.Но эта операция завершится ошибкой, тоже , потому что файл доступен только для записи и не позволяет нам использовать метод read ().

Файл режима только записи не читается 
 file = open ('OpenFile.txt', 'ш') file.write ('Новое содержимое \ n') file.close ()

Приведенный выше код полностью очистит все содержимое текстового файла и вместо этого просто скажет «Новое содержимое».

Если вы не хотите перезаписывать файл, вы можете использовать режимы a + или r + .

Режим r + будет записывать любой контент, переданный методу write () . 

 файл = открытый ('OpenFile.txt', 'r +') печать (file.read ()) file.write ('метод r +, добавляет строку \ n') file.close ()

Режим a или a + будет выполнять то же действие, что и режим r +, с одним основным отличием.

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

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

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

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

 с open ('OpenFile.txt', 'r +') как файл: печать (file.read ())
Вывод в открытый файл Python

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

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

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

 с open ('OpenFile.txt', 'r +') как файл: lines = file.readlines () для строки в строках: печать (line.split ())
С помощью команды Открыть файл Python 1

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

Заключение

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

.

Открытие файла Python

Работа с файлами - важная часть любого веб-приложения.

Python имеет несколько функций для создания, чтения, обновления и удаление файлов.

Работа с файлами

Ключевой функцией для работы с файлами в Python является open () функция.

Функция open () принимает два параметра; имя файла и режим .

Существует четыре различных метода (режима) открытия файла:

"r" - Чтение - Значение по умолчанию.Открывает файл для чтения, ошибка, если файл не существует

"a" - Приложение - открывает файл для добавление, создает файл, если он не существует

"w" - Запись - Открывает файл для записи, создает файл, если он не существует

"x" - Create - Создает указанный файл, возвращает ошибка если файл существует

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

"t" - Текст - значение по умолчанию.Текстовый режим

"b" - Двоичный - Двоичный режим (например, изображения)

Синтаксис

Чтобы открыть файл для чтения, достаточно указать имя файла:

Код выше такой же, как:

f = open ("demofile.txt", "rt")

Потому что "r" для чтения и «t» для текста - значения по умолчанию, указывать их не нужно.

Примечание: Убедитесь, что файл существует, иначе вы получите сообщение об ошибке.


.

Создание, открытие, добавление, чтение, запись

  • На главную

  • Тестирование

      • Назад
      • Гибкое тестирование
      • BugZilla
      • Cucumber
      • Тестирование базы данных
      • Тестирование ETL
        • Назад
        • JUnit
        • LoadRunner
        • Ручное тестирование
        • Мобильное тестирование
        • Mantis
        • Почтальон
        • QTP
        • Назад
        • Центр качества
        • 000300030003 SoapUI
        • Управление тестированием
        • TestLink

    • SAP

        • Назад
        • ABAP
        • APO
        • Начинающий
        • Basis
        • BODS
        • BI
        • BPC
        • CO
        • Назад
        • CRM
        • Crystal Reports
        • FICO
        • 000 HRM
        • 000 HRM
        • MM Pay
        • Назад
        • PI / PO
        • PP
        • SD
        • SAPUI5
        • Безопасность
        • Менеджер решений
        • Successfactors
        • SAP Tutorials

    • Web
    • Web
    • AngularJS
    • ASP.Net
    • C
    • C #
    • C ++
    • CodeIgniter
    • СУБД
    • JavaScript
    • Назад
    • Java
    • JSP
    • Kotlin
    • Linux
    • Linux js
    • Perl
    • Назад
    • PHP
    • PL / SQL
    • PostgreSQL
    • Python
    • ReactJS
    • Ruby & Rails
    • Scala
    • SQL
      • 000 0003 SQL 000
    • SQL
      • 000
    • UML
    • VB.Net
    • VBScript
    • Веб-службы
    • WPF

  • Обязательно учите!

      • Назад
      • Бухгалтерский учет
      • Алгоритмы
      • Android
      • Блокчейн
      • Бизнес-аналитик
      • Создание веб-сайта
      • Облачные вычисления
      • COBOL
      • Встроенные системы
      • 9000 Проектирование встраиваемых систем
        • 900 Ethical 9003
      • Учебные пособия по Excel
      • Программирование на Go
      • IoT
      • ITIL
      • Jenkins
      • MIS
      • Сетевые подключения
      • Операционная система
      • Назад
      • Prep
      • PM Prep
      • Управление проектом Salesforce
      • SEO
      • Разработка программного обеспечения
      • VBA
      900 04

  • Большие данные

      • Назад
      • AWS
      • BigData
      • Cassandra
      • Cognos
      • Хранилище данных
      • DevOps Back
      • DevOps Back
      • HBase
        • HBase2
        • MongoDB
        • NiFi
    .

    Чтение и запись файлов на Python (Руководство) - Real Python