Содержание

Открывать, работать и закрывать файлы в Python

Шаги по открытию файла: open ==> operation ==> close

1. Открытие файла

f = open ('/ tmp / pass', 'r +') ## Первый параметр в скобках - это файл, который нужно открыть, а второй параметр указывает, какие права доступа требуются для работы с файлом
 ## Следующее - разрешение второго параметра
"""
 r: (по умолчанию)
         -Можно только читать, но не писать
         -Если прочитанный файл не существует, будет сообщено об ошибке
    
r+:
         -Чтение и запись
         -Если прочитанный файл не существует, будет сообщено об ошибке
    
w:
    -write only
         -Очистит предыдущее содержимое файла
         -Файл не существует, ошибка не будет сообщаться, будет создан и записан новый файл
w+:
    -rw
         -Очистит содержимое файла
         -Файл не существует, об ошибках не будет, будет создан новый файл
    
a:
    -write only
         -Не очищает содержимое файла
         -Файл не существует, ошибка не будет сообщаться, будет создан и записан новый файл
a+:
    -rw
         -Ошибка не отображается, если файл не существует
         -Не очищает содержимое файла
b:
         Двоичный
"""

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

print (f. readable ()) ## Оценка читаемости
 print (f.writable ()) ## Оцените, доступен ли он для записи

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

1) Прочтите содержимое файла

content = f.read () ## прочитает все содержимое файла, выведет в одну строку
 content = f.read (3) ## прочитает первые 3 файла 
 print (f.readline ()) ## Прочитать и вывести первую строку файла
 print (f.readlines ()) ## Прочитать содержимое файла, вернуть список, элементы списка являются содержимым строки файла

2) Записать в файл

f.write ('hello') ## Добавить привет в последнюю строку файла

3) Положение указателя

print(f.tell())

метод поиска для перемещения указателя

Первый параметр поиска — смещение:> 0, что означает движение вправо, <0, что означает движение влево.
Второй параметр поиска:
0: переместить указатель в начало файла.
1: не перемещать указатель
2: переместите указатель в конец

f.seek (-1,2) ## означает переместить два юнита влево

4) Работа с непростым текстом

Следующая операция предназначена для копирования изображения

f1 = open('1111.
jpg',mode='rb') content = f1.read() f1.close() f2 = open('westos.jpg',mode='wb') f2.write(content) f2.close()

3. Закрытие файла

f.close () ## Открытый файл должен быть закрыт, иначе он всегда будет занимать системные ресурсы

4.with

Диспетчер контекста: откройте файл и автоматически закройте объект файла после выполнения содержимого инструкции with

Как следующая структура

# Открыть два файловых объекта одновременно
with open('/tmp/passwd') as f1,\
    open('/tmp/passwdbackup','w+') as f2:
         # Записываем содержимое первого файла во второй файл
    f2.write(f1.read())
         # Переместить указатель в начало файла
    f2.seek(0)
         # Читать содержимое файла
    print(f2.read())

5. Практика

Создайте файл data.txt, в файле всего 100000 строк, в каждой строке хранится целое число от 1 до 100, и прочтите содержимое файла после записи.

import random
f = open('date. txt','a+')
for i in range(100000):
    f.write(str(random.randint(1,100)) + '\n')
f.seek(0,0)
print(f.read())
f.close()

ok~


Интеллектуальная рекомендация

Развитие iOS — один случай

Что такое один пример, цель пения? Когда класс — это только один экземпляр, вам необходимо использовать один пример, то есть этот класс имеет только один объект, который не может быть выпущен во время…

Разница между typeof, instanceof и конструктором в js

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

Установка и использование Cocoapods, обработка ошибок

Использование какао-стручков Общие команды CocoaPods: $pod setup Обновите все сторонние индексные файлы Podspec в локальном каталоге ~ / .CocoaPods / repos / и обновите локальное хранилище. $pod repo …

Коллекция инструментов с неограниченной скоростью для облачного диска Baidu

Примечание: Недавно я обнаружил, что скорость загрузки файлов на Baidu Cloud Disk очень низкая. Лао-цзы не может выкупить участников. Невозможно выкупить участников в этой жизни. Если у вас нет денег,…

Шаблон проектирования — Подробное объяснение шаблона заводского метода

Предисловие В предыдущей статье «Шаблон проектирования — Подробное объяснение простого шаблона Factory», мы можем знать, что у простой фабричной модели есть некоторые недостатки: Класс фабри…

Вам также может понравиться

29 сентября, весенняя облачная суббота

Ложь, правда и ложь, как в шахматы, но кто пешка? «Тень»…

Logstash Delete Field.

Проблема После того, как FileBeat приобретает информацию журнала, Logstash Prints Information. В этом процессе FileBeat передает свою собственную информацию о клиентах в логисту, если лог-журнал отфил…

Глава 2 2.1-2.16 Предварительный просмотр

2.1 Системный каталог Структура Команда: ls = список Используется для перечисления системных каталогов или файлов Корневой каталог является каталогом пользователя, сохраняет файл конфигурации или друг. ..

Java фактическое боевое боевое издание 103 страниц Ответ

Алгоритм лунного календаря, включая праздники, солнечные термины, сезонные и т. Д.

Эпоха (день 0): пятница, 22 декабря 1899 года, григорианский календарь против китайского Нового года (двадцать пять лет в Гуансу), 20 ноября, зимнее солнцестояние Цзяцзы Диапазон лунного календаря: с …

Чтение данных из файла и запись в файл. Программирование на Python

Создание файла

В Python, чтобы создать файл, надо его открыть в режиме записи (‘w’, ‘wb’) или дозаписи (‘a’, ‘ab’).

f2 = open("text2.txt", 'w')

Функция open() возвращает файловый объект.

Без ‘b’ создается текстовый файл, представляющий собой поток символов. С ‘b’ — файл, содержащий поток байтов.

В Python также существует режим ‘x’ или ‘xb’. В этом режиме проверяется, есть ли файл. Если файл с определенным именем уже существует, он не будет создан. В режиме ‘w’ файл создается заново, старый при этом теряется.

>>> f1 = open('text1.txt', 'w')
>>> f2 = open('text1.txt', 'x')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
FileExistsError: [Errno 17] File exists: 'text1.txt'
>>> f3 = open('text1.txt', 'w')

Чтение данных из файла

Если в функцию open() не передается второй аргумент, файл расценивается как текстовый и открывается на чтение.

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

>>> f = open("text10.txt")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IOError: [Errno 2] No such file or directory: 'text10.txt'

Перехватить возникшее исключение можно с помощью конструкции try-except.

>>> try:
...     f = open("text10.txt")
... except IOError:
...     print ("No file")
... 
No file

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

>>> f = open("text.txt")
>>> f
<_io.TextIOWrapper name='text.txt' mode='r' encoding='UTF-8'>
>>> fd = f.read()
>>> fd1 = f.read()
>>> fd
'Hello\n\tOne\n   Two\nThree Four\nШесть!\n'
>>> fd1
''

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

>>> f = open("text.txt")
>>> fd = f.read(10)
>>> fd1 = f.read(5)
>>> fd
'Hello\n\tOne'
>>> fd1
'\n   T'

Метод readline() позволяет получать данные построчно.

>>> f = open("text.txt")
>>> f.readline()
'Hello\n'
>>> f.readline()
'\tOne\n'
>>> f.readline()
'   Two\n'

Принимает аргумент — число байт.

>>> f.readline(3)
'Thr'
>>> f.readline(3)
'ee '
>>> f.readline(3)
'Fou'
>>> f.readline(3)
'r\n'
>>> f. readline(5)
'Шесть'
>>> f.readline(5)
'!\n'

Метод readlines() считывает все строки и помещает их в список.

>>> f = open("text.txt")
>>> fd = f.readlines()
>>> fd
['Hello\n', '\tOne\n', '   Two\n', 'Three Four\n', 'Шесть!\n']

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

>>> f = open("text.txt")
>>> fd = f.readlines(3)
>>> fd
['Hello\n']
>>> fd1 = f.readlines(6)
>>> fd1
['\tOne\n', '   Two\n']

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

Записать данные в файл можно с помощью метода write(), который возвращает число записанных символов.

>>> f1 = open("text1.txt", 'w')
>>> f1.write("Table, cup.\nBig, small.")
23
>>> a = f1.write("Table, cup.\nBig, small.")
>>> type(a)
<class 'int'>

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

>>> f1. read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
io.UnsupportedOperation: not readable
>>> f1.close()
>>> f1 = open("text1.txt", 'r')
>>> f1.read()
'Table, cup.\nBig, small.Table, cup.\nBig, small.'

С помощью метода writelines() можно записать в файл итерируемую последовательность.

>>> a = [1,2,3,4,5,6,7,8,9,0]
>>> f = open("text2.txt",'w')
>>> f.writelines("%s\n" % i for i in a)
>>> f.close()
>>> open("text2.txt").read()
'1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n'
>>> print(open("text2.txt").read())
1
2
3
4
5
6
7
8
9
0

Смена позиции в файле

>>> f = open('text.txt')
>>> f.read()
'Hello\n\tOne\n   Two\nThree Four\nШесть!\n'
>>> f.close()
>>> f = open('text.txt')
>>> f.seek(10)
10
>>> f.read()
'\n   Two\nThree Four\nШесть!\n'

Двоичные файлы

Пример копирования изображения:

>>> f1 = open('flag. png', 'rb')
>>> f2 = open('flag2.png', 'wb')
>>> f2.write(f1.read())
446
>>> f1.close()
>>> f2.close()

Модуль struct позволяет преобразовывать данные к бинарному виду и обратно.

>>> f = open('text3.txt', 'wb')
>>> f.write('3')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' does not support the buffer interface
>>> d = struct.pack('>i',3)
>>> d
b'\x00\x00\x00\x03'
>>> f.write(d)
4
>>> f.close()
>>> f = open('text3.txt')
>>> d = f.read()
>>> d
'\x00\x00\x00\x03'
>>> struct.unpack('>i',d)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'str' does not support the buffer interface
>>> f = open('text3.txt', 'rb')
>>> d = f.read()
>>> d
b'\x00\x00\x00\x03'
>>> struct.unpack('>i',d)
(3,)

Как прочитать файлы в Python и решить проблему с кодировками

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

Открываем, а затем читаем или записываем

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

with open('file.txt') as f:
    data = f.read() # содержимое файла

Таким же образом можно записать информацию в файл, указав w в качестве аргумента:

text = 'Hello'
with open('file.txt', 'w') as f:
    f.write(text)

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

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

f = open('file.txt')
f.read()
f.close()

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

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

На многих операционных системах Python в качестве стандарта кодирования использует UTF-8, который также поддерживает кириллицу. Тем не менее, часто можно столкнуться с проблемами неправильной кодировки и получить распространенную ошибку вроде этой:

>>> f = open('somefile.txt', encoding='ascii')
>>> f.read()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/usr/local/lib/Python3.8/encodings/ascii.py", line 26, in decode
    return codecs.ascii_decode(input, self. errors)[0]
UnicodeDecodeError: 'ascii' codec can't decode byte 0xc3 in position
12: ordinal not in range(128))

В примере указана кодировка ASCII, но файл закодирован в другом формате, поэтому и возникает такая ошибка. Решить ее можно тремя способами:

  1. Указать erorr=replace, который заменит нераспознанные символы знаком ?:
    >>> f = open('somefile.txt', encoding='ascii', errors='replace')
    >>> f.read()
    'H?llo py?ho?-school!'
    
  2. Указать erorr=ignore, который проигнорирует нераспознанные символы:
    >>> f = open('somefile.txt', encoding='ascii', errors='replace')
    >>> f.read()
    'Hllo pyho-school!'
    
  3. Указать правильную кодировку. Если текст на русском языке, то можно посмотреть кодировки с поддержкой кириллицы, которые есть в документации Python. Например, явно указать UTF-8 или cp1251:
    f = open('somefile. txt', encoding='utf-8')
    # или cp1251
    f = open('somefile.txt', encoding='cp1251')
    
Добавление в конец и запрет открытия файлов

Как мы уже отметили ранее, для записи текстового файла добавляется аргумент w. Но если вызвать метод write, он перепишет весь файл. Во многих случаях требуется добавить данные в конец файла. Тогда используется a вместо w:

text2 = 'world'
with open('file.txt', 'a') as f:
    f.write(text)
# Helloworld

Если файла не существует, то при a и при w он будет создан. Но чтобы не трогать существующие файлы, а создать новый, передается параметр x:

# 'x' не даст возможности открыть файл, так как он существует
>>> with open('file.txt', 'x') as f:
...    f.write(text2)
FileExistsError                           Traceback (most recent call last)

  FileExistsError: [Errno 17] File exists: 'file. txt'

# Поскольку file2.txt не существует, все OK
>>> with open('file2.txt', 'x') as f:
...    f.write(text2)
Временные файлы

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

>>> from tempfile import TemporaryFile
>>> f = TemporaryFile("w+t")
>>> f.write("hello")
>>> f.seek(0)
>>> f.read()
'hello'
>>> f.close() # файл уничтожается
# либо в контекстном менеджере
    f.write(text2)

Обратите внимание на 3 вещи. Первое, мы явно передаем "w+t", чтобы записать как текстовый файл, поскольку по умолчанию стоит "w+b" для бинарных файлов. Второе, метод seek(0) используется для перехода на самый первый символ, поскольку чтение происходит с текущего указателя, а он стоит в конце (после буквы ‘o’ в слове ‘hello’). Поэтому не стоит переживать, что мы можем стереть предыдущую запись:

>>> f.seek(5) # переходим в конец
>>> f.read()
''
>>> f.write("world")
5
>>> f.seek(0) # переходим в начало
>>> f.read()
'helloworld'

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

Именованные временные файлы

А вот объекты класса NamedTemporaryFile будут видны файловой системе, и найти месторасположение можно с помощью атрибута name:

>>> from tempfile import NamedTemporaryFile
>>> f = NamedTemporaryFile("w+t")
>>> f. name
'/tmp/tmp60djsgli'
>>> f.close()

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

>>> f = NamedTemporaryFile("w+t", prefix="myfile", suffix=".txt")
>>> f.name
'/tmp/myfile7mxae0fi.txt'
Временные папки

Кроме временных файлов можно создавать временные папки. Для этого используется класс TemporaryDirectory:

>>> from tempfile import TemporaryDirectory
>>> d = TemporaryDirectory()
>>> d.name
'/tmp/tmp5eadqzz5'

Он также принимает в качестве аргументов prefix и suffix, а также может использоваться внутри контекстного менеджера Python.

 

В следующей статье поговорим о взаимодействии файловой системы и Python. А получить практические навыки работы с файлами на реальных проектах Data Science вы сможете на наших курсах по Python в лицензированном учебном центре обучения и повышения квалификации IT-специалистов в Москве.

Смотреть расписание

Записаться на курс

Источники

  1. https://docs.python.org/3/library/functions.html#open
  2. https://docs.python.org/3/library/tempfile.html

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:

print( file.read() )

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

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

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

print( file.read(2) )

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

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

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

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

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

seek(offset[, from_what])

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

file.seek(0)

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

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 = file. readlines()

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

print( s )

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

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

file.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)

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

print( int(s) )

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

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

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

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

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

file.write("Hello World!")

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

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

file.write("Hello")

И снова выполним эту программу. Смотрите, в нашем файле 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:

file.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:

import pickle

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

pickle.dump(books, file)

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

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

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

bs = pickle.load(file)

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

print( 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»: «река»}

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

Видео по теме

#1. Первое знакомство с Python Установка на компьютер

#2. Варианты исполнения команд. Переходим в PyCharm

#3. Переменные, оператор присваивания, функции type и id

#4. Числовые типы, арифметические операции

#5. Математические функции и работа с модулем math

#6. Функции print() и input(). Преобразование строк в числа int() и float()

#7. Логический тип bool. Операторы сравнения и операторы and, or, not

#8. Введение в строки. Базовые операции над строками

#9. Знакомство с индексами и срезами строк

#10. Основные методы строк

#11. Спецсимволы, экранирование символов, row-строки

#12. Форматирование строк: метод format и F-строки

#13. Списки — операторы и функции работы с ними

#14. Срезы списков и сравнение списков

#15. Основные методы списков

#16. Вложенные списки, многомерные списки

#17. Условный оператор if. Конструкция if-else

#18. Вложенные условия и множественный выбор. Конструкция if-elif-else

#19. Тернарный условный оператор. Вложенное тернарное условие

#20. Оператор цикла while

#21. Операторы циклов break, continue и else

#22. Оператор цикла for. Функция range()

#23. Примеры работы оператора цикла for. Функция enumerate()

#24. Итератор и итерируемые объекты. Функции iter() и next()

#25. Вложенные циклы. Примеры задач с вложенными циклами

#26. Треугольник Паскаля как пример работы вложенных циклов

#27. Генераторы списков (List comprehensions)

#28. Вложенные генераторы списков

#29. Введение в словари (dict). Базовые операции над словарями

#30. Методы словаря, перебор элементов словаря в цикле

#31. Кортежи (tuple) и их методы

#32. Множества (set) и их методы

#33. Операции над множествами, сравнение множеств

#34. Генераторы множеств и генераторы словарей

#35. Функции: первое знакомство, определение def и их вызов

#36. Оператор return в функциях. Функциональное программирование

#37. Алгоритм Евклида для нахождения НОД

#38. Именованные аргументы. Фактические и формальные параметры

#39. Функции с произвольным числом параметров *args и **kwargs

#40. Операторы * и ** для упаковки и распаковки коллекций

#41. Рекурсивные функции

#42. Анонимные (lambda) функции

#43. Области видимости переменных. Ключевые слова global и nonlocal

#44. Замыкания в Python

#45. Введение в декораторы функций

#46. Декораторы с параметрами. Сохранение свойств декорируемых функций

#47. Импорт стандартных модулей. Команды import и from

#48. Импорт собственных модулей

#49. Установка сторонних модулей (pip install). Пакетная установка

#50. Пакеты (package) в Python. Вложенные пакеты

#51. Функция open. Чтение данных из файла

#52. Исключение FileNotFoundError и менеджер контекста (with) для файлов

#53. Запись данных в файл в текстовом и бинарном режимах

#54. Выражения генераторы

#55. Функция-генератор. Оператор yield

#56. Функция map. Примеры ее использования

#57. Функция filter для отбора значений итерируемых объектов

#58. Функция zip. Примеры использования

#59. Сортировка с помощью метода sort и функции sorted

#60. Аргумент key для сортировки коллекций по ключу

#61. Функции isinstance и type для проверки типов данных

#62. Функции all и any. Примеры их использования

#63. Расширенное представление чисел. Системы счисления

#64. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы

#65. Модуль random стандартной библиотеки

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

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

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

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

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

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

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

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

open ("demo.txt")

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  • buffering
  • encoding
  • errors
  • newline
  • closefd
  • opener

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

Английский для программистов

Наш телеграм канал с тестами по английскому языку для программистов. Английский это часть карьеры программиста. Поэтому полезно заняться им уже сейчас

Подробнее

×

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

This is the first line
This is the second line

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

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

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

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

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

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

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

Grosery Store List:
Chicken
Mango
Rice
Chocolate Cake

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

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

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

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

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

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

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

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

Заключение

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Файл используется для постоянного хранения данных. Работа с файлом — очень распространенная задача любого языка программирования. В Python существует множество встроенных функций для создания, открытия, чтения, записи и закрытия файла. Для хранения данных можно создать два типа файлов. Это текстовые файлы и двоичные файлы. Любой файл необходимо открыть перед чтением или записью. Функция open() используется в Python для открытия файла. Использование функции open() — это один из способов проверить, открыт или закрыт конкретный файл. Если функция open() открывает ранее открытый файл, генерируется ошибка IOError. Другой способ проверить, открыт или закрыт файл — это проверить значения свойства closed объекта обработчика файлов. С использованием функции rename() — еще один способ проверить, открыт или закрыт файл. В этой статье показаны различные способы проверки открытия или закрытия любого файла в Python.

 

Создайте файл для проверки:

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


ID     Name                           Email
01     Andrey Ex                   Andrey***@gmail. com
02     Max Terminator              Max***@gmail.com
03    Alex Murphy                  Alex***@gmail.com

 

Пример-1: проверьте, открыт файл или нет, с помощью IOError

IOError генерируется при вызове функции open() для открытия файла, который был открыт ранее. Создайте файл python со следующим сценарием, чтобы проверить, открыт ли файл или нет, с помощью блока try-except. Здесь любое существующее имя файла будет принято в качестве входных и открыто для чтения. Затем снова вызывается функция open(), чтобы открыть тот же файл, который вызовет ошибку IOError и распечатает сообщение об ошибке.

# Введите имя файла для проверки
filename = input("Введите любое существующее имя файла:\n")
# Откройте файл в первый раз с помощью функции open()
fileHandler = open(filename, "r")
# Попробуйте открыть файл с таким же именем снова
try:
with open("filename", "r") as file:
# Распечатать сообщение об успешном завершении
print("Файл открыт для чтения. ")
# Вызовите ошибку, если файл был открыт раньше
except IOError:
print("Файл уже открыт")

Вывод:

Здесь в текущем расположении существует файл clients.txt, а сообщение об ошибке «Файл уже открыт» было напечатано для исключения IOError.

 

Пример-2: проверьте, закрыт ли файл, используя свойство closed.

Значение свойства closed будет истинным, если какой-либо файл закрыт. Создайте файл python с помощью следующего сценария, чтобы проверить, закрыт ли файл в текущем местоположении. Предыдущий пример сценария выдаст ошибку, если имя файла, полученное от пользователя, не существует в текущем местоположении. В этом примере эта проблема решена. Модуль os используется здесь для проверки существования имени файла, которое будет взято у пользователя. Функция check_closed() определена для проверки того, закрыт ли файл или нет, которая будет вызываться, если файл существует.

# Импортировать модуль os для проверки существования файла
import os
# Функция Drfine проверяет, закрыт ли файл или нет
def check_closed():
if fileHandler. closed == False:
# Распечатать сообщение об успешном завершении
print("Файл открыт для чтения.")
else:
# Распечатать сообщение об ошибке
print(" Файл закрыт.")

# Взять имя файла для проверки
filename = input(" Введите любое существующее имя файла: \ n ")
# Проверить, существует
if os.path.exists(filename):
# Открыть файл для чтения
fileHandler = open(filename, "r")
# Вызвать функцию
check_closed()
else:
# Вывести сообщение, если файл не существует
print("Файл не существует.")

Вывод:

Здесь client.txt существует в текущем месте, и сообщение об успешном завершении «Файл открыт для чтения» напечатано, поскольку значение свойства closed вернуло False.

 

Пример-3: проверьте, открыт файл или нет, с помощью OSError

OSError генерирует , когда функция переименования() вызывается более чем один раз для файла , который открыт уже. Создайте файл Python со следующим сценарием, чтобы проверить, открыт или закрыт файл с помощью OSError.  Модуль os использовался в сценарии для проверки существования файла и его переименования. Когда функция rename() вызывается во второй раз, будет сгенерирована ошибка OSError, и будет напечатано настраиваемое сообщение об ошибке.

# Импортировать модуль os для проверки существования файла
import os
# Установить существующее имя файла
filename = 'clients.txt'
# Установить новое имя файла
newname = 'customers.txt'
# Проверить, существует ли файл или нет,
if os.path.exists(filename):
try:
# Вызов функции переименования в первый раз
os.rename(filename, newname)
# Вызов функции переименования во второй раз
os.rename(filename, newname)
# Вызов исключения при ошибки, если если файл открыт
except OSError:
print («Файл все еще открыт».)

else:
# Вывести сообщение, если файл не существует
print("Файл не существует.")

Вывод:

Здесь clients.txt существует в текущем местоположении, и сообщение об ошибке, “File is still opened,” напечатал , потому что OSError исключение генерируется , когда вторая функция rename() выполнена.

 

Вывод:

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

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

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

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

Существует два типа файлов, которые можно обрабатывать в Python: обычные текстовые файлы и двоичные файлы (написанные на двоичном языке, 0 и 1). Открытие файла относится к подготовке файла либо к чтению, либо к записи. Это можно сделать с помощью функция open() . Эта функция возвращает файловый объект и принимает два аргумента, один из которых принимает имя файла, а другой принимает режим (режим доступа).

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

Синтаксис: File_object = open(«File_Name», «Access_Mode»)

Параметры:  

  • File_Name: Это имя файла, который необходимо открыть.
  • Access_Mode: Режимы доступа определяют тип операций, возможных в открытом файле. В таблице ниже приведены список всего режима доступа, доступного в Python
.
Операция Синтаксис Описание
только чтение R
Чтение и запись r+ Открыть файл для чтения и записи.
Только запись w Открыть файл для записи.
Запись и чтение w+ Открыть файл для чтения и записи. В отличие от «r+», это не вызывает ошибку ввода-вывода, если файл не существует.
Добавить только a Открыть файл для записи и создать новый файл, если он не существует. Все дополнения делаются в конце файла, и никакие существующие данные не могут быть изменены.
Добавить и прочитать a+ Открыть файл для чтения и записи и создать новый файл, если он не существует. Все дополнения делаются в конце файла, и никакие существующие данные не могут быть изменены.

Пример 1:  Открыть и прочитать файл с помощью Python

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

Код:

Python3

file = open ( "sample. txt" )

 

print ( file .read())

Здесь мы открыли файл и распечатали его содержимое.

Вывод:  

 Привет, Компьютерщик!
Это образец текстового файла для примера. 

Пример 2:   Открытие и запись в файл с помощью Python

В этом примере мы будем добавлять новое содержимое к существующему файлу. So the initial file looks like the below: 

 

Code:  

Python3

file = open ( "sample.txt" , ' a' )

 

файл . write( "Этот текст был недавно добавлен в файл образца" )

Теперь, если вы откроете файл, вы увидите приведенный ниже результат,

Выход:

Пример 3: Открыть и перевернуть файл Python

в этом примере 3: . , мы перезапишем содержимое файла примера следующим кодом:

Код:

Python3

file = 1 1 open0120 ( "sample.txt" , 'w' )

 

file .write( " All content has been overwritten !" )

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

Вывод:

Пример 4.

Создание файла, если он не существует в Python

Метод path.touch() модуля pathlib создает файл в путь, указанный в пути path.touch().

Python3

1 (MY__FILE) 9003 1 (MY__FILE) 1 (MY__FIL0006

 

Закрытие файла в Python

Как вы заметили, мы не закрыли ни один из файлов, над которыми мы работали в приведенных выше примерах. Хотя Python автоматически закрывает файл, если ссылочный объект файла выделяется для другого файла, стандартная практика — закрытие открытого файла, поскольку закрытый файл снижает риск необоснованного изменения или чтения.
Python имеет метод close() для закрытия файла. Метод close() можно вызывать более одного раза, и если какая-либо операция выполняется с закрытым файлом, возникает ошибка ValueError. В приведенном ниже коде показано простое использование метода close() для закрытия открытого файла.

Пример: Читать и закройте файл с использованием Python

Python3

from pathlib import Path

 

my_file = Path( 'test1/myfile.txt' )

MY_FILE.Touch (ESTED_OK = TRUE )

F = Open (MY__FILE) 9013 1 (MY__FILE) 903

Файл = Open ( " ( ". Print ( Файл .Read ())

Файл . close ()

1

Теперь, когда мы пробуем все, что вы найдете в Amport Wis Pile On Pilece We Al Amport Wis Pile On Pail On Pilece We At Arame Pile On Pail. возникает ошибка ValueError: 

Python3

file = open ( "sample.txt" )

    

print ( file .read( )

Файл .close ()

Файл .WRITE ( ».0048

Вывод:

 ValueError: Операция ввода/вывода в закрытом файле. 

Почему важно закрывать файлы в Python? – Real Python

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

 с помощью open("hello.txt", mode="w") в качестве файла:
    file.write("Привет, мир!")
 

Оператор с оператором инициирует диспетчер контекста. В этом примере диспетчер контекста открывает файл hello.txt и управляет файловым ресурсом, пока контекст активен. В общем, весь код в блоке с отступом зависит от того, какой файловый объект открыт. Как только блок с отступом заканчивается или вызывает исключение, файл закрывается.

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

 попытка:
    файл = открыть ("hello.txt", режим = "w")
    file.write("Привет, мир!")
в конце концов:
    файл.закрыть()
 

Блок finally , который закрывает файл, выполняется безоговорочно, независимо от того, успешен или нет блок try . Хотя этот синтаксис эффективно закрывает файл, менеджер контекста Python предлагает менее подробный и более интуитивно понятный синтаксис. Кроме того, это немного более гибко, чем просто обертывание вашего кода попробовать наконец .

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

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

Вкратце: файлы — это ресурсы, ограниченные операционной системой

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

Когда вы открываете файл с помощью open() , вы выполняете системный вызов в операционную систему, чтобы найти этот файл на жестком диске и подготовить его для чтения или записи. Затем операционная система вернет целое число без знака, называемое 9.дескриптор файла 0005 в Windows и дескриптор файла в UNIX-подобных системах, включая Linux и macOS:

Процесс Python выполняет системный вызов и получает целое число 10 в качестве дескриптора файла

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

>>>

 >>> с open("test_file.txt", mode="w") в качестве файла:
... файл. fileno()
...
4
 

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

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

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

Примечание : Некоторые библиотеки имеют специальные методы и функции, которые, кажется, открывают файлы без менеджера контекста. Например, в библиотеке pathlib есть .write_text() , а в pandas — read_csv() .

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

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

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