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

Выявление ошибок

Иногда, в ходе работы, ошибки случаются. Файл может быть закрыт, потому что какой-то другой процесс пользуется им в данный момент или из-за наличия той или иной ошибки разрешения. Когда это происходит, может появиться IOError. В данном разделе мы попробуем выявить эти ошибки обычным способом, и с применением оператора with. Подсказка: данная идея применима к обоим способам.

try: file_handler = open(«test.txt») for line in file_handler: print(line) except IOError: print(«An IOError has occurred!») finally: file_handler.close()

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

try: with open(«test.txt») as file_handler: for line in file_handler: print(line) except IOError: print(«An IOError has occurred!»)

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

Подведем итоги

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

python-scripts.com

Работа с файлами в питон

В этом уроке мы разберём, как читать файлы и писать в файлах в Питоне. В файлы записываются результаты работы программы, которые можно потом использовать в других приложениях. Поэтому необходимо уметь в Питон записывать информацию в файлыТакже в файлах может храниться большой объем входной информации, которую должна обработать программа. Поэтому необходимо уметь считывать информацию из файлов в python.
Чтобы начать работу с файлом  в Питон, нужно открыть файл. Открыть файл в Питон можно, прописав команду
with open(“file.ext”, mode) as name: имя перменной файла
with, open и as это ключевые слова. Команда open() открывает файл с именем “file” с разрешением файла “ext”. Параметр mode отвечает за режим открытия файла. Необходимо указать полный путь к файлу, причем используются слеши Например, можно открыть файл только для считывания информации из файла, можно открыть файл для добавления в него информации, можно просто создать новый файл с заданным именем. Название и расширение файла пишется в кавычках, расширение файла пишется после названия файла через точку, режим открытия пишется в кавычках. В таблице ниже приведены некоторые режимы открытия файла в Питон. 

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

 Разберём режим чтения файла “r”. Создайте новую программу в Spyder, сохраните её на Рабочем столе. Там же создайте текстовый документ text с расширением txt. Внутри напишите следующий текст.
1) Привет! Я первая строка.
2) Вторая строка.
3) Третья строка.
Чтобы вывести в программе  Питон  в консоль весь файл, используйте команду f.read().
Пример. Программа python читает весь файл и выводит его в консоль.
with open(«text.txt», «r») as f:
    text = f.read()
    print(text)
Команда f.read(n) может принимать аргумент n, n это количество знаков с начала, которое будет считываться из файла. Например, если будет исполняться команда f.read(50), то программа выведет 50 знаков с начала файла.
Пример. Программа в Python для считывания опредленного количества знаков
with open(«text.txt», «r») as f:
    text = f.read(50)
    print(text)
Если вы хотите читать текст не с начала файла, а с какого-либо символа, используйте команду f.seek(n), n это символ, с которого начнётся чтение файла. Файл начинается с нулевого символа.
Пример. Программа на Python для чтение файла с начала второй строки.
with open(«text.txt», «r») as f:
    f.seek(27)
    text = f.read(50)
    print(text)
Python позволяет считать все строки текста файла в отдельный массив с помощью команды f.readlines()
Пример. Программа python выводит в консоль третью строку файла.
with open(«text.txt», «r») as f:
    text = f.readlines()
    print(text[2])
Если вы хотите считывать все строки по отдельности, не записывая их в массив, используется команда f.readline()  Команда будет считывать одну строку из файла. Если использовать эту команду несколько раз, то они будут выводить разные строки. Например, если вы написали две команды f.readline(), то первая команда выведет первую строку, вторая команда выведет вторую строку.
Пример программы python считывание строк из файла с помощью команды f.readline().
with open(«text.txt», «r») as f:
    text = f.readline()
    print(text)
    print(f.readline())
Часто отдельные части данных разделены каким-либо знаком. Python заменять эти знаки из строк с помощью команды f.replace(start, final), где start это знак, который надо заменить, final это знак, на который надо заменить.
Пример программы, заменяющей все пробелы в строке на знак +.
string = «Всем привет! Я строка.»
print(string.replace(» «, «+»))

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

Разберём режим добавления информации в файл в Питон  “w” Для добавления информации в файл в python используется команда f.write(“text”) Эта команда удаляет весь старый текст в файле и вместо него пишет новый. Чтобы это увидеть, перед запуском программы с этой командой посмотрите в файл text.txt, там должны быть строки текста. После исполнения программы с этой командой зайдите в тот же файл, там не должно быть старых строк, вместо них будет текст, который вы написали в команде.
Пример программа на Python запись текста в файл с использованием команды f.write().
with open(«text.txt», «w») as f:
    f.write(«Текст.»)
Вместо этого текста
1) Привет! Я первая строка.
2) Вторая строка.
3) Третья строка.
Должна появиться эта строка
Текст.
Чтобы написать несколько строк, используйте команду f.writelines(line), где line это массив со строками, которые нужно напечатать.
Пример. Программа нв Python для записи массива строк в файл
with open(«text.txt», «w») as f:
    f.writelines([«Первый элемент. «, «Вторая строка.»])
Разберём режим добавления информации “a”. Этот режим отличается от “w” тем, что он не удаляет старую информацию, когда пишет, в отличии от “w”. Все команды в режиме “a” идентичны командам в режиме “w”, но в режиме “a” команды не удаляют старый текст, а пишут новый в конце файла.
Разберём большой пример работы с файлами в Python. Дан текстовый файл data с двумя столбцами и десятью строками однозначных или двузначных чисел. Числа разделены пробелом. Для каждой строки нужно найти среднее этих чисел и вывести их в новый текстовый файл result.
Файл data.
11 47
59 15
2 52
64 48
58 88
59 86
37 39
19 92
48 85
16 78
Введём массив для обычных строк line[], массив для строк без пробелов aC[], массив для чисел в каждом столбце a1[] и a2[] и массив res[], в котором будут находиться средние значения.
Откроем файл data.txt и считаем из него числа. Введём цикл for на 10 итераций (повторений) по количеству строк. Считаем строку под номером i с помощью команды f.readline() и запишем её в массив с индексом i line[i].
line[i] = f.readline()
Чтобы удалить пробелы между числами, используем команду line[i].replace(“ ”, “”), при её исполнении все пробелы в строке под номером i заменятся на пустую строку. Чтобы оперировать с получившимися числами, нужно перевести их из строк в числа, для этого используется int(aC[i]). У нас получаются трёх- или четырёхзначные числа. Чтобы отделить первое число от второго, нужно использовать целочисленное деление. В целых числах разделим каждый элемент массив aC[] на 100, чтобы отбросить часть числа до сотых.
a1[i] = aC[i] // 100
Например, у нас есть число 1147, это комбинация чисел 11 и 47. Если это число мы разделим на 100, то целая часть результата будет равна 11, а остаток будет равен 47. Деление в целых числах отбрасывает остаток, оставляя только целую часть. Таким образом, мы получим первое число. Второе число будет равно остатку от деления на 100.
a2[i] = aC[i] % 100
Мы получили два числа от каждой строки. Теперь нужно найти их среднее арифметическое. Все средние значения мы запишем в массив res[i].
for i in range(10):
    res[i] = (a1[i] + a2[i]) / 2
Чтобы записать все результаты в новый файл, откроем файл result.txt в режиме “a”. С помощью цикла for запишем все результаты в отдельные строки.
with open(«result.txt», «a») as result:
    for i in range(10):
        res[i] = str(res[i])
        result.write(res[i] + » «)
Полный код программы python считывание числовых столбцов из файла и запись в файл столбца средних значений
# вводим массивы
line = {} # строки
aC = {} # строки без пробелов 
a1 = {} # первое число
a2 = {} # второе число
res = {} # результат — среднее арифметическое
# выводится в новый файл

with open(«data.txt», «r») as f:
    for i in range(10):
        line[i] = f.readline()
        aC[i] = line[i].replace(» «, «»)
        aC[i] = int(aC[i])
        a1[i] = aC[i] // 100
        a2[i] = aC[i] % 100     
for i in range(10):
    res[i] = (a1[i] + a2[i]) / 2
    print(res[i])

with open(«result.txt», «a») as result:
    for i in range(10):
        res[i] = str(res[i])
        result.write(res[i] + » «)

Вернуться к содержанию Следующая тема Библиотека NumPy в Python матрицы в питон

Поделиться:

itrobo.ru

Программирование на Python: Часть 8. Файловая система

Программирование на Python

Сергей Яковлев
Опубликовано 02.09.2010

Серия контента:

Этот контент является частью # из серии # статей: Программирование на Python

https://www.ibm.com/developerworks/ru/library/?series_title_by=**auto**

Следите за выходом новых статей этой серии.

Этот контент является частью серии:Программирование на Python

Следите за выходом новых статей этой серии.

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

Сегодня мы рассмотрим следующие темы.

1. Как открыть файл.
2. Базовые файловые методы.
3. Стандартный ввод/вывод.
4. Произвольный доступ.
5. Построчная работа с файлами.
6. Закрытие файла.
7. Итерация.
8. Pickling.
9. Бинарные файлы – модуль struct.
10. Работа с файловой системой.

1. Как открыть файл

Открыть файл можно с помощью функции open:

  open(name[, mode[, buffering]])

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

‘r’ – чтение.

‘w’ – запись.

‘a’ – добавление.

‘b’ – бинарный режим.

‘+’ – чтение/запись.

Режим ‘+’ может быть добавлен к остальным режимам. По умолчанию питон открывает файлы в текстовом режиме. Для открытия файла в бинарном режиме на чтение можно добавить ‘rb’. Третий параметр устанавливает размер буферизации при работе с файлом. По умолчанию он выключен, и чтение/запись идет напрямую с диска на диск. Для включения буфера третий параметр должен быть отличным от нуля.

2. Базовые файловые методы

В питоне многие объекты являются файлами: стандартный ввод sys.stdin, стандартный вывод sys.stdout, объекты, открываемые функцией urllib.urlopen и т.д.

Запись в файл:

>>> f = open('my_file', 'w')
>>> f.write('Hello, ')
>>> f.write('World!')
>>> f.close()

Чтение:

>>> f = open('my_file', 'r')
>>> f.read(5)
'Hello'
>>> f.read()
', World!'

3. Стандартный ввод/вывод

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

  cat my_file | python test.py

Первая команда – cat – пишет содержимое текстового файла my_file на стандартный вывод sys.stdout . Вторая команда запускает питоновский файл, который читает стандартный ввод sys.stdin , подсчитывает в нем количество слов и выводит результат:

test.py:
import sys
text = sys.stdin.read()
words = text.split()
wordcount = len(words)
print 'Wordcount:', wordcount

Канал – или пайп (pipe) – это конструкция, объединяющая стандартный вывод со стандартным вводом и позволяющая обмениваться данными между двумя командами.

4. Произвольный доступ

По умолчанию метод read() читает данные последовательно по порядку, от начала и до конца файла. Для произвольного доступа к файлу есть функция seek:

  seek(offset[, whence])

offset – смещение в байтах относительно начала файла;

whence – по умолчанию равен нулю, указывает на то, что смещение берется относительно начала файла.

Пример:

>>> f = open(r'my_file', 'w')
>>> f.write('01234567890123456789')
>>> f.seek(5)
>>> f.write('Hello, World!')
>>> f.close()
>>> f = open(r'my_file')
>>> f.read()
'01234Hello, World!89'

Функция tell() возвращает текущую позицию файла.

5. Построчная работа с файлами

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

  file.readline()

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

  file.readlines()

Записать строки в файл:

  file.writelines()

Пример. Прочитать файл и записать его содержимое в другой файл:

f = open(r'my_file')
lines = f.readlines()
f.close()
lines[0] = "This is a my_file2 \n" # изменяем 1-ю строку
f = open(r'my_file2','w')
f.writelines(lines)
f.close()

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

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

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

Для полной уверенности в закрытии файла можно использовать блок try/finally:

  try:
     # Тут идет запись в файл
  finally:
     file.close()

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

 with open("my_file") as somefile:
    do_something(somefile)

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

7. Итерация

Итерация по файлу является базовой операцией и имеет множество вариантов. Использование функции read() для байтового чтения:

f = open(filename)
while True:
  char = f.read(1)
  if not char: break
  process(char)
f.close()

Построчное чтение текстовых файлов и функция readline():

f = open(filename)
while True:
  line = f.readline()
  if not line: break
  process(line)
f.close()

Файл сам может выступать в роли итератора:

for line in open(filename):
  process(line)

8. Pickling

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

import pickle
t1 = [1, 2, 3]
s = pickle.dumps(t1)
t2 = pickle.loads(s)
print t2
[1, 2, 3]

Здесь есть небольшой нюанс: t1 и t2 будут двумя разными объектами, хотя и идентичными.

9. Бинарные файлы

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

Функции этого модуля:

   pack(format, value1, value2 ...)

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

   unpack(format, string)

Распаковывает строку string в соответствии с форматом format и возвращает кортеж объектов.

   calcsize(format)

Возвращает размер структуры (т.е. длину строки), соответствующей формату format.

Таблица основных форматов

===========================
Format      C Type          Python 	
===========================
c             char               string of length 1 	 
?             Bool              bool 	
i 	   int                  integer 	 
l 	   long               integer 	 
f 	   float               float 	 
d 	   double           float 	 
s 	   char[]            string

Перед символом формата может идти число, обозначающее количество повторений. Например, строка формата ‘4h’ полностью эквивалентна строке ‘hhhh’. Символы пропуска между символами формата игнорируются, однако символы пропуска между числом и символом формата не допускаются.

Число перед символом формата ‘s’ интерпретируется как длина строки, а не число повторений. То есть ’10s’ обозначает строку из 10 символов, в то время как ’10c’ – 10 раз по одному символу.

Можно изменить порядок следования байтов вручную:

  < - little-endian
  > - big-endian

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

from struct import *
out = open("123.bin", "wb")    
format = "if5s"                
data   = pack(format, 24,12.48,'12345')
out.write(data)
out.close()
input = open("123.bin", "rb")
data = input.read()
input.close()
format = "if5s"                   # one integer
value,value2,value3 = unpack(format, data) # note the ',' in 'value,': 
	unpack apparently returns a n-uple
print value
print value2
print value3
print calcsize(format)

>>> 24
>>> 12.4799995422
>>> 12345
>>> 13

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

Стандартный модуль os имеет интерфейс работы с файловой системой. Каждая программа имеет текущий каталог. Функция os.getcwd возвращает текущий каталог:

import os
cwd = os.getcwd()
print cwd

Проверить наличие файла в текущем каталоге:

  os.path.exists('my_file')

Вывести список файлов и подкаталогов для данного каталога:

  os.listdir(path)

Следующий пример рекурсивно выводит список всех файлов и подкаталогов для данного каталога:

import os
def walk(dir):
  for name in os.listdir(dir):
    path = os.path.join(dir, name)
    if os.path.isfile(path):
        print path
    else:
        walk(path)
walk(path)

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

import os, sys
def getlocaldata(sms,dr,flst):
   for f in flst:
      fullf = os.path.join(dr,f)
      if os.path.islink(fullf): continue # don't count linked files
      if os.path.isfile(fullf):
          sms[0] += os.path.getsize(fullf)
          sms[1] += 1
      else:
          sms[2] += 1
def dtstat(dtroot):
   sums = [0,0,1] # 0 bytes, 0 files, 1 directory so far
   os.path.walk(dtroot,getlocaldata,sums)
   return sums

report = dtstat('.')
print report

В следующем примере сделана интерпретация системной утилиты grep. В текущем каталоге будут найдены файлы с питоновским расширением, в которых будет найдена поисковая строка ‘import os’:

import os, sys, fnmatch

mask = '*.py'
pattern = 'import os'

def walk(arg,dir,files):
   for file in files:
     if fnmatch.fnmatch(file,mask):
        name = os.path.join(dir,file)
        try:
          data = open(name,'rb').read()
          if data.find(pattern) != -1:
            print name
        except:
            pass    
os.path.walk('.',walk,[])

Заключение

Сегодня мы узнали, что файловые объекты поддерживают чтение/запись. Для корректной работы с данными файл нужно программно закрывать. Файлы можно открывать в различных режимах. Стандартный ввод/вывод – это тоже файлы. Можно построчно читать и писать в файл. К файлам можно применять байтовую и построчную итерацию. Любые объекты могут быть сохранены на диске в произвольный момент времени в произвольном состоянии и позже восстановлены путем считывания с диска. Чтение/запись можно выполнять в бинарном режиме, соблюдая совместимость со структурами на языке си. Интерфейс с операционной системой позволяет писать компактные программы, дополняющие стандартные утилиты операционной системы.

Приведенные примеры проверены на версии питона 2.6.

< Предыдущая статья. Следующая статья >

Ресурсы для скачивания

Подпишите меня на уведомления к комментариям

www.ibm.com

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

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

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

my_file = open(filename, filemode)

Здесь filename — это строковый аргумент, который указывает имя файла вместе с его путем, а filemode также является строковым аргументом, который используется для указания способа использования файла, то есть для чтения или записи. И my_file — это объект обработчика файлов, также известный как указатель на файл.

Пример:

my_file = open(«my_file.txt», «r») # Open a file print («Name of the file: «, my_file.name) print («Opening mode : «, my_file.mode)

Вывод:

Name of the file: my_file.txt Opening mode : r

В приведенном выше примере откройте текстовый файл с именем «my_file.txt» в режиме только чтения.

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

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

Пример:

my_file = open(«my_file.txt», «r») # Open a file # do file operations. my_file.close()

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

Метод close() не совсем безопасен. Если возникает исключение, когда мы выполняем некоторую операцию с файлом, код выходит из него, не закрывая файл. Лучше использовать try … finally block.

Пример:

try: my_file = open(«my_file.txt», «r») # Open a file # do some file operations. finally: my_file.close()

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

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

Пример:

with open(«my_file.txt», «r») as my_file: # do some file operations

В приведенном выше примере вам не нужно явно вызывать метод close(). Это делается внутренне.

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

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

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

os.rename (old_file_name, new_file_name)

Пример:

import os cur_file = «file1.txt» new_file = «file2.txt» os.rename(cur_file, new_file)

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

Пример:

import os cur_file = «file1.txt» os.remove(cur_file)

Источник: net-informations.com

bunkerbook.ru

Чтение и запись файлов в Python

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

Файл – это именованная область диска, предназначенная для длительного хранения данных в постоянной памяти (например, на жёстком диске).

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

Поэтому в Python операции с файлами выполняются в следующем порядке:

1. Открытие файла.
2. Чтение или запись (выполнение операции).
3. Закрытие файла.

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

>>> f = open("test.txt")    # открыть файл в текущей папке
>>> f = open("C:/Python33/README.txt")  # указание полного пути

При этом можно указать необходимый режим открытия файла: ‘r’- для чтения,’w’  — для записи,’a’ — для изменения. Мы также можем указать, хотим ли открыть файл в текстовом или в бинарном формате.

По умолчанию файл открывается для чтения в текстовом режиме. При чтении файла в этом режиме мы получаем строки.

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

f = open("test.txt")      # эквивалент 'r' или 'rt'
f = open("test.txt",'w')  # запись в текстовом режиме
f = open("img.bmp",'r+b') # чтение и запись в бинарном формате

В отличие от других языков программирования, в Python символ ‘a’ не подразумевает число 97, если оно не закодировано в ASCII (или другой эквивалентной кодировке).

Кодировка по умолчанию зависит от платформы. В Windows – это ‘cp1252’, а в Linux ‘utf-8’.

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

f = open("test.txt",mode = 'r',encoding = 'utf-8')

Закрытие освободит ресурсы, которые были связаны с файлом. Это делается с помощью метода close(), встроенного в язык программирования Python.

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

f = open("test.txt",encoding = 'utf-8')
# выполнение операций с файлом
f.close()

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

Более безопасный способ – использование блока try…finally.

try:
   f = open("test.txt",encoding = 'utf-8')
   # выполнение операций с файлом
finally:
   f.close()

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

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

with open("test.txt",encoding = 'utf-8') as f:
   # выполнение операций с файлом

Чтобы записать данные в файл в Python, нужно открыть его в режиме ‘w’, ‘a’ или ‘x’. Но будьте осторожны с режимом ‘w’. Он перезаписывает файл, если то уже существует. Все данные в этом случае стираются.

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

with open("test.txt",'w',encoding = 'utf-8') as f:
   f.write("my first filen")
   f.write("This filenn")
   f.write("contains three linesn")

Эта программа создаст новый файл ‘test.txt’. Если он существует, данные файла будут перезаписаны. При этом нужно добавлять символы новой строки самостоятельно, чтобы разделять строки.

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

>>> f = open("test.txt",'r',encoding = 'utf-8')
>>> f.read(4)    # чтение первых 4 символов
'This'

>>> f.read(4)    # чтение следующих 4 символов
' is '

>>> f.read()     # чтение остальных данных до конца файла
'my first filenThis filencontains three linesn'

>>> f.read()  # дальнейшие попытки чтения возвращают пустую строку
''

Метод read() возвращает новые строки как ‘n’. Когда будет достигнут конец файла, при дальнейших попытках чтения мы получим пустые строки.

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

>>> f.tell()    # получаем текущую позицию курсора в файле
56

>>> f.seek(0)   # возвращаем курсор в начальную позицию
0

>>> print(f.read())  # читаем весь файл
This is my first file
This file
contains three lines

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

>>> for line in f:
...     print(line, end = '')
...
This is my first file
This file
contains three lines

Извлекаемые из файла строки включают в себя символ новой строки ‘n’. Чтобы избежать вывода, используем пустой параметр end метода print(),.

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

>>> f.readline()
'This is my first filen'

>>> f.readline()
'This filen'

>>> f.readline()
'contains three linesn'

>>> f.readline()
''

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

>>> f.readlines()
['This is my first filen', 'This filen', 'contains three linesn']

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

Данная публикация представляет собой перевод статьи «Python File IO Read and Write Files in Python» , подготовленной дружной командой проекта Интернет-технологии.ру

www.internet-technologies.ru