Содержание

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

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

Последнее обновление: 29.04.2017

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

При работе с файлами необходимо соблюдать некоторую последовательность операций:

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

  2. Чтение файла с помощью метода read() или запись в файл посредством метода write()

  3. Закрытие файла методом close()

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

Чтобы начать работу с файлом, его надо открыть с помощью функции open(), которая имеет следующее формальное определение:

open(file, mode)

Первый параметр функции представляет путь к файлу. Путь файла может быть абсолютным, то есть начинаться с буквы диска, например, C://somedir/somefile.txt. Либо можно быть относительным, например, somedir/somefile.txt — в этом случае поиск файла будет идти относительно расположения запущенного скрипта Python.

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

  • r (Read). Файл открывается для чтения. Если файл не найден, то генерируется исключение FileNotFoundError

  • w (Write). Файл открывается для записи. Если файл отсутствует, то он создается. Если подобный файл уже есть, то он создается заново, и соответственно старые данные в нем стираются.

  • a (Append). Файл открывается для дозаписи. Если файл отсутствует, то он создается. Если подобный файл уже есть, то данные записываются в его конец.

  • b (Binary). Используется для работы с бинарными файлами. Применяется вместе с другими режимами — w или r.

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

Например, откроем для записи текстовый файл «hello.txt»:


myfile = open("hello.txt", "w")

myfile.close()

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

В этом случае мы можем обрабатывать исключения:


try:
    somefile = open("hello.txt", "w")
    try:
        somefile.write("hello world")
    except Exception as e:
        print(e)
    finally:
        somefile.close()
except Exception as ex:
    print(ex)

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

Однако есть и более удобная конструкция — конструкция with:


with open(file, mode) as file_obj:
	инструкции

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

Так, перепишем предыдущий пример:


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

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

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

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

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

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

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

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

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

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

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

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

Режимы открытия файлов в Python
РежимОписание
‘r’Открытие файла для чтения. Режим используется по умолчанию.
‘w’Открытие файла для записи. Режим создаёт новый файл, если он не существует, или стирает содержимое существующего.
‘x’Открытие файла для записи. Если файл существует, операция заканчивается неудачей (исключением).
‘a’Открытие файла для добавления данных в конец файла без очистки его содержимого. Этот режим создаёт новый файл, если он не существует.
‘t’Открытие файла в текстовом формате. Этот режим используется по умолчанию.
‘b’Открытие файла в бинарном формате.
‘+’Открытие файла для обновления (чтения и записи).
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
МетодОписание
close()Закрытие файла. Не делает ничего, если файл закрыт.
detach()Отделяет бинарный буфер от TextIOBase и возвращает его.
fileno()Возвращает целочисленный дескриптор файла.
flush()Вызывает сброс данных (запись на диск) из буфера записи файлового потока.
isatty()Возвращает значение True, если файловый поток интерактивный.
read(n)Читает максимум n символов из файла. Читает до конца файла, если значение отрицательное или None.
readable()Возвращает значение True, если из файлового потока можно осуществить чтение.
readline(n=-1)Читает и возвращает одну строку из файла. Читает максимум n байт, если указано соответствующее значение.
readlines(n=-1)Читает и возвращает список строк из файла. Читает максимум n байт/символов, если указано соответствующее значение.
seek(offset,from=SEEK_SET)Изменяет позицию курсора.
seekable()Возвращает значение True, если файловый поток поддерживает случайный доступ.
tell()Возвращает текущую позицию курсора в файле.
truncate(size=None)
Изменяет размер файлового потока до size байт. Если значение size не указано, размер изменяется до текущего положения курсора.
writable()Возвращает значение True, если в файловый поток может производиться запись.
write(s)Записывает строки s в файл и возвращает количество записанных символов.
writelines(lines)Записывает список строк lines в файл.

 

 

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

Python. Урок 12. Ввод-вывод данных. Работа с файлами

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

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

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

>>> print("Hello")
Hello
>>> print("Hello, " + "world!")
Hello, world!
>>> print("Age: " + str(23))
Age: 23

По умолчанию, для разделения элементов в функции print используется пробел.

>>> print("A", "B", "C")
A B C

Для замены разделителя необходимо использовать параметр sep функции print.

print("A", "B", "C", sep="#")
A#B#C

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

>>> for i in range(3):
    print("i: " + str(i))   
i: 0
i: 1
i: 2

Для его замены используется параметр end.

>>> for i in range(3):
    print("[i: " + str(i) + "]", end=" -- ")
[i: 0] -- [i: 1] -- [i: 2] -- 

Для считывания вводимых с клавиатуры данных используется функция input().

>>> input()
test
'test'

Для сохранения данных в переменной используется следующий синтаксис.

>>> a = input()
hello
>>> print(a)
hello

Если считывается с клавиатуры целое число, то строку, получаемую с помощью функции input(), можно передать сразу в функцию int().

>>> val = int(input())
123
>>> print(val)
123
>>> type(val)
<class 'int'>

Для вывода строки-приглашения, используйте ее в качестве аргумента функции input().

>>> tv = int(input("input number: "))
input number: 334
>>> print(tv)
334

Преобразование строки в список осуществляется с помощью метода split(), по умолчанию, в качестве разделителя, используется пробел.

>>> l = input().split()
1 2 3 4 5 6 7
>>> print(l)
['1', '2', '3', '4', '5', '6', '7']

Разделитель можно заменить, указав его в качестве аргумента метода split().

>>> nl = input().split("-")
1-2-3-4-5-6-7
>>> print(nl)
['1', '2', '3', '4', '5', '6', '7']

Для считывания списка чисел с одновременным приведением их к типу int можно воспользоваться вот такой конструкцией.

>>> nums = map(int, input().split())
1 2 3 4 5 6 7
>>> print(list(nums))
[1, 2, 3, 4, 5, 6, 7]

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

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

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

r’ – открыть файл для чтения;

w’ – открыть файл для записи;

x’ – открыть файл с целью создания, если файл существует, то вызов функции open завершится с ошибкой;

a’ – открыть файл для записи, при этом новые данные будут добавлены в конец файла, без удаления существующих;

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

t’ – текстовый режим;

+’ – открывает файл для обновления.

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

У файлового объекта есть следующие атрибуты.

file.closed – возвращает true если файл закрыт и false в противном случае;

file.mode – возвращает режим доступа к файлу, при этом файл должен быть открыт;

file.name – имя файла.

>>> f = open("test.txt", "r")
>>> print("file.closed: " + str(f.closed))
file.closed: False
>>> print("file.mode: " + f.mode)
file.mode: r
>>> print("file.name: " + f.name)
file.name: test.txt

Для закрытия файла используется метод close().

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

Чтение данных из файла осуществляется с помощью методов read(размер) и readline().

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

>>> f = open("test.txt", "r")
>>> f.read()
'1 2 3 4 5\nWork with file\n'
>>> f.close()

В качестве аргумента метода можно передать количество символом, которое нужно считать.

>>> f = open("test.txt", "r")
>>> f.read(5)
'1 2 3'
>>> f.close()

Метод readline() позволяет считать строку из открытого файла.

>>> f = open("test.txt", "r")
>>> f.readline()
'1 2 3 4 5\n'
>>> f.close()

Построчное считывание можно организовать с  помощью оператора for.

>>> f = open("test.txt", "r")
>>> for line in f:
...     print(line)
...
1 2 3 4 5
Work with file

>>> f.close()

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

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

>>> f = open("test.txt", "a")
>>> f.write("Test string")
11
>>> f.close()

Дополнительные методы для работы с файлами

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

>>> f = open("test.txt", "r")
>>> f.read(5)
'1 2 3'
>>> f.tell()
5
>>> f.close()

Метод seek(позиция) выставляет позицию в файле.

>>> f = open("test.txt", "r")
>>> f.tell()
0
>>> f.seek(8)
8
>>> f.read(1)
'5'
>>> f.tell()
9
>>> f.close()

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

>>> with open("test.txt", "r") as f:
...     for line in f:
...             print(line)
...
1 2 3 4 5
Work with file
Test string
>>> f.closed
True

P.S.

Если вам интересна тема анализа данных, то мы рекомендуем ознакомиться с библиотекой Pandas. На нашем сайте вы можете найти вводные уроки по этой теме. Все уроки по библиотеке Pandas собраны в книге “Pandas. Работа с данными”.
Книга: Pandas. Работа с данными
<<< Python. Урок 11. Работа с исключениями   Python. Урок 13. Модули и пакеты >>>

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

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

with open(«C:\Users\user\Desktop\Win\Python\settings\data.txt»,»r») as f:

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

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

 Разберём режим чтения из файла “r”. Создайте новую программу в Spyder, сохраните её на Рабочем столе.  Создайте на рабочем столе текстовый документ text с расширением txt. Внутри файла напишите следующий текст.
 Привет! Я первая строка.
 Вторая строка.
Третья строка.
Чтобы вывести в программе Питон  в консоль весь файл, используется команда 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”) Эта команда удаляет весь старый текст в файле и вместо него пишет новый. После исполнения программы с этой командой зайдите в тот же файл, там не должно быть старых строк, вместо них будет текст, который вы написали в команде.
Пример программа на Python запись текста в файл с использованием команды f.write().
with open(«text.txt», «w») as f:
    f.write(«Текст.»)
Вместо этого текста
Привет! Я первая строка.
Вторая строка.
Третья строка.
Должна появиться эта строка
Текст.
Чтобы написать несколько строк, используется команда f.writelines(line), где line это массив со строками, которые нужно записать в файл
Программа на Python для записи массива строк в файл
with open(«text.txt», «w») as f:
    f.writelines([«Первый элемент. «, «Вторая строка.»])
Разберём режим добавления информации “a”. Этот режим отличается от “w” тем, что он не удаляет старую информацию. Все команды в режиме “a” идентичны командам в режиме “w”, но в режиме “a” команды не удаляют старый текст, а записывают текст в конце файла.
Часто в программах на python входная информация считывается из файла, обрабатывается и результат записывается в новый выходной файл. Разберём большой пример работы с файлами в 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() и запишем её в массив с индексом line[i]
line[i] = f.readline()
Чтобы получить доступ к каждому чилу в строке, необходимо воспользоваться методом split, который удаляет разделитель и записывает все элементы строки в массив уже без разделителя. Подробнее о работе со строками в python

Для считывания всех строк файла и перевода их в массивы необходимо написать следующий код
line = {} # строки
with open(«C:\Users\user\Desktop\Win\Python\settings\data.txt»,»r») as f:
    for i in range(10):
        line[i] = f.readline()
        stroka=line[i].split(‘ ‘)

Чтобы получить из строки stroka числовые значения первого элемента и второго, воспользуемся функцией int(). В массив res[i] запишем среднее арифметическое двух элементов строки

       a=int(stroka[0])
       b=int(stroka[1])
       res[i]=(a+b)/2

Чтобы записать все результаты в новый файл, откроем файл result.txt в режиме “a”. С помощью цикла for запишем все результаты в отдельные строки.
with open(«C:\Users\user\Desktop\Win\Python\settings\result.txt», «a») as result:
    for i in range(10):
        res[i] = str(res[i])
        result.write(res[i] + » «)
Полный код программы python считывание числовых столбцов из файла и запись в файл столбца средних значений

line = {} # строки
res={}
with open(«C:\Users\user\Desktop\Win\Python\settings\data.txt»,»r») as f:
    for i in range(10):
        line[i] = f.readline()
        stroka=line[i].split(‘ ‘)
        a=int(stroka[0])
        b=int(stroka[1])
        res[i]=(a+b)/2
with open(«C:\Users\user\Desktop\Win\Python\settings\result.txt», «a») as result:
    for i in range(10):
        res[i] = str(res[i])
        result.write(res[i] + » «)

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

Поделиться:

 

 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Поиск строки

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

«my_file.txt»

или

«d:\\app\\my_file.txt»

или так:

«d:/app/my_file.txt»

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

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

«images/img.txt»

или так:

«d:/app/images/img.txt»

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

«../out.txt»

«d:/out.txt»

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

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

«../parent/prt.dat»

«d:/ parent/prt.dat»

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

file = open("myfile.txt")

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

file = open("myfile2.txt")

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

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

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

mode = «r»

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

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

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

Название

Описание

‘r’

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

‘w’

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

‘x’

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

‘a’

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

Дополнения

‘b’

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

‘t’

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

‘+’

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

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

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

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

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

file = open("myfile.txt")

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

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

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

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

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

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

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

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

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

seek(offset[, from_what])

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

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

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

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

pos = file.tell()
print( pos )

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

s = file.readline()
print( s )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

finally:
    print(file.closed)

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

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

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

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

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

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

file.write("Hello World!")

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

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

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

w, wt, wb,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Чтение файлов с помощью Python — GitJournal

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

Основы работы с файлами в Python

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

Когда открывается файл для чтения, Python нужно точно знать, как следует открыть файл в системе. Доступны два способа  — обычное чтение и чтение в двоичном режиме. Соответствующие флаги имеют вид  rи rbи должны быть определены, когда файл открывается встроенным методом open(). Первый режим включает в себя интерпретацию специальных символов вроде «CR» (возврат каретки) and «LF» (перенос строки), чтобы отобразить разрыв строки, тогда как двоичный режим позволяет вам считывать данные в сыром виде — где данные хранятся как есть безо всякой дальнейшей интерпретации.

Как только вы открыли файл, методopen()вернёт вам файловый объект. Эти файловые объекты содержат методы наподобиеread(), readline(), write(), tell()и seek(). Хотя сами они (или подобные объекты) имеют больше методов, чем указано здесь, эти встречаются наиболее часто. Не каждый файловый объект нуждаются в имплементации всех методов работы с файлами.

Примеры

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

Построчное чтение файла

Первый пример вдохновлён двумя языками программирования: C и C++. Он довольно простой: открываем файл с помощью метода open(), читаем файл построчно, используя метод readline(), и выводим строку сразу же после чтения. Здесь применяется цикл while, который непрерывно читает из файла, пока метод readline() продолжает возвращать данные. В случае конца файла (EOF) цикл while останавливается, и файловый объект закрывается, освобождая ресурсы для других программ.

# определим имя файла, который читаем
filename = "test.txt"

# открываем файл для чтения
filehandle = open(filename, 'r')  
while True:  
    # читаем одну строку
    line = filehandle.readline()
    if not line:
        break
    print(line)

# закрываем указатель на этот файл
filehandle.close()  

Листинг 1

Как вы могли заметить, в листинге 1 мы явно открыли и закрыли файл (строки 5 и 14 соответственно). Хотя интерпретатор Python закрывает открытые файлы автоматически в конце исполнения программы, явно закрывать файл через close() есть хороший стиль программирования, и это не следует забывать.

В качестве улучшения в языке Python 2.3 был введён удобный протокол итераторов. Это позволяет вам упростить цикл readline следующим образом:

# определим имя файла, который читаем
filename = "test.txt"

for line in open(filename, 'r'):  
    print(line)

Листинг 2

Здесть применяется цикл for в комбинации с итератором in. Файл открывается в строке 4 листинга 2. Текущая строка определяется с помощью итератора in, считывается из файла, и её содержимое подаётся на выход stdout в строке 5. Python скрывает открытие и закрытие файла, когда закончится исполнение. Хотя такой способ неэффективен, он позволяет вам больше не иметь дело с файловым потоком.

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

# определим имя файла, который читаем
filename = "test.txt"

with open(filename, 'r') as filehandle:  
    for line in filehandle:
        print(line)

Листинг 3

Комбинация оператора with и команды open() открывает файл только один раз (строка 4). Если цикл for завершён успешно, содержимое файла напечатано в поток stdout (строки 5 и 6).

Более того, использование выражения with даёт побочный эффект. Внутри интерпретатора Python создаётся блок tryfinally, чтобы инкапсулировать чтение из файла. Листинг 4 показывает, что неизбежно случается внутри в Python с помощью блоков кодаwith:

try:  
    filehandle = open(filename, 'r')
    # что-то делаем
finally:  
    filehandle.close()

Листинг 4

Чтение файла как набора строк

До сих пор мы обрабатывали файл построчно. Это довольно медленный способ для огромных файлов, но его можно улучшить, если читать несколько строк одновременно. Чтобы этого добиться, в дело вступает метод islice() из модуля itertools. Также он работает как итератор и возвращает набор данных, состоящий из n строк. В конце файла результат может быть короче, и завершающий вызов вернёт пустой список.

from itertools import islice

# определим имя файла, который читаем
filename = "test.txt"

# определим, сколько строк нужно прочесть
number_of_lines = 5

with open(filename, 'r') as input_file:  
    lines_cache = islice(input_file, number_of_lines)

    for current_line in lines_cache:
        print (current_line)

Листинг 5

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

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

# определим имя файла, который читаем
filename = "test.txt"

# определим номер строки
line_number = 3

print ("line %i of %s is: " % (line_number, filename))

with open(filename, 'r') as filehandle:  
current_line = 1  
    for line in filehandle:
        if current_line == line_number:
            print(line)
            break
        current_line += 1

Листинг 6

Листинг 6 достаточно просто понять, но он немного больше, чем предыдущие примеры. Его можно сократить, используя модуль linecache. Листинг 7 поазывает, как упростить код с помощью метода getline(). Если запрашиваемая строка выпадает из ряда валидных строк в файле, то метод getline() взамен возвращает пустую строку.

# импортируем модуль linecache
import linecache

# определим имя файла, который читаем
filename = "test.txt"

# определим номер строки
line_number = 3

# получим определённую строку
line = linecache.getline(filename, line_number)  
print ("line %i of %s:" % (line_number, filename))  
print (line)  

Листинг 7

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

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

# определим имя файла, который читаем
filename = "test.txt"

with open(filename, 'r') as filehandle:  
    filecontent = filehandle.read()
    print (filecontent)

Листинг 8

Python также предлагает метод readlines(), похожий на метод readline() из первого примера. В отличие от read(), содержимое файла сохраняется в список, где каждый элемент есть строка содержимого. Листинг 9 показывает, как получить доступ к этим данным:

# определим имя файла, который читаем
filename = "test.txt"

with open(filename, 'r') as filehandle:  
    filecontent = filehandle.readlines()
    for line in filecontent:
        print (line)

Листинг 9

Хотя readlines() будет читать содержимое из файла, пока не наткнётся на EOF (конец файла), не забывайте, что вы также можете ограничить количество прочитанного параметром sizehint, — числом байт, которое нужно прочесть.

Вывод

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

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

Работа с файловым вводом-выводом в Python — dbader.org

Автор: Дэн Бадер — Получайте бесплатные обновления новых сообщений здесь.

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

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

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

Вот что мы расскажем:

  • Разница между двоичным файлом и текстовым файлом
  • Где найти встроенные функции и инструменты ввода-вывода файлов Python
  • Как открывать и закрывать файлы в Python
  • Различные способы чтения данных из файла в Python
  • Как записать данные в объект файла в Python
  • Файл ищет в Python и перемещает указатель чтения / записи
  • Редактирование существующего текстового файла с помощью Python

Приступим!

Двоичные и текстовые файлы в Python

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

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

  • Файлы изображений, включая .jpg , .png , .bmp , .gif и т. Д.
  • Файлы базы данных, включая .mdb , .frm и .sqlite
  • Документы, включая .doc , .xls , .pdf и другие.

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

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

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

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

Где найти инструменты ввода-вывода файлов Python

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

На других языках, таких как C ++, для работы с файлами необходимо включить инструменты файлового ввода-вывода, включив правильный файл заголовка, например #include .А если вы пишете код на Java, вам понадобится оператор import java.io. * .

Для Python в этом нет необходимости —

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

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

Первая функция, которую вам нужно знать, — это open () . Как в Python 2, так и в Python 3 эта команда вернет объект файла, как указано в параметрах.Основное использование функции для open () следующее:

 file_object = open (имя файла, режим)
 

В этом случае filename — это имя файла, с которым вы хотите взаимодействовать, с включенным расширением файла. То есть, если у вас есть текстовый файл workData.txt , ваше имя файла будет не просто "workData" . Это

.

Работа с текстовыми файлами в Python

Содержание

Цели урока

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

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

Работа с текстовыми файлами

Python упрощает работу с файлами и текстом. Давайте начнем с файлы.

Создание и запись в текстовый файл

Начнем с краткого обсуждения терминологии. На предыдущем уроке (в зависимости от вашей операционной системы: установка Mac, Windows Установка, или Установка Linux), вы видели, как отправить информацию в окно «Вывод команд» текстового редактора с помощью Команда печати Python.

Язык программирования Python объектно-ориентированный .То есть сказать, что он построен вокруг особого вида сущности, объекта , который содержит данные и несколько методов для доступа и изменения эти данные. После создания объект может взаимодействовать с другими объекты.

В приведенном выше примере мы видим один тип объектов, строку «привет Мир». Строка — это последовательность символов, заключенная в кавычки. Вы можно записать строку одним из трех способов:

  message1 = 'привет, мир'
message2 = "привет, мир"
message3 = "" "привет
Привет
Привет мир"""
  

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

Например, все следующее неверно:

  message1 = "привет, мир"
message2 = 'привет, мир "
message3 = 'Я не могу есть соленья'
  

Подсчитать количество одинарных кавычек в сообщении 3. Чтобы это сработало, вы пришлось бы избежать апостроф:

  message3 = 'Я не могу есть соленые огурцы'
  

Или перепишите фразу как:

  message3 = "Я не могу есть соленые огурцы"
  

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

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

Вы будете использовать print , как это в тех случаях, когда вы хотите создать информация, которая требует немедленных действий. Однако иногда вы будете создавать информацию, которую хотите сохранить, чтобы отправить кто-то другой, или использовать в качестве входных данных для дальнейшей обработки другим программа или набор программ. В этих случаях вы захотите отправить информацию в файлы на жестком диске, а не в «Команда Вывод ».Введите следующую программу в текстовый редактор и сохраните это как file-output.py .

  # file-output.py
f = открытый ('helloworld.txt', 'wb')
f.write ('привет мир')
f.close ()
  

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

В этой программе f — это объект файла , а открыть , записать и закрыть — это файл методы . Другими словами, open, write и close что-то делают с объект f , который в данном случае определяется как файл .txt . Это вероятно другое использование термина «метод», чем вы могли ожидать, и время от времени со временем вы обнаружите, что слова используются в программе

.

Работа с файлами — Python для биологов

Почему нас так интересует работа с файлами?

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

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

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

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

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

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

  • Файлы FASTA последовательностей ДНК или белков
  • файлов, содержащих вывод программ командной строки (например, BLAST)
  • Файлы FASTQ, содержащие секвенирование ДНК, читает
  • HTML файлов
  • и, конечно, сам код Python

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

  • файлов изображений (JPEG и PNG)
  • аудиофайлов
  • видео файлов
  • сжатых файлов (например, файлов ZIP)

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

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

Использование open для чтения файла

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

  my_file = open ("dna.txt")  

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

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

  my_string = 'abcdefg'
печать (моя_строка)
my_number = 42
print (my_number + 1)  

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

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

  my_file = open ("dna.текст")
file_contents = my_file.read ()
print (file_contents)  

Файлы, содержимое и имена файлов

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

  my_file_name = "dna.txt" ❶
my_file = open (my_file_name) ❷
my_file_contents = my_file.read () ❸  

Что здесь происходит? Сначала мы сохраняем строку dna.txt в переменной my_file_name ❶.Затем мы используем переменную my_file_name в качестве аргумента функции open () и сохраняем полученный файловый объект в переменной my_file ❷. Наконец, мы вызываем метод read () для переменной my_file и сохраняем полученную строку в переменной my_file_contents ❸.

Важно понимать, что в этом коде есть три отдельные переменные, которые имеют разные типы и хранят три очень разные вещи:

  • my_file_name — это строка, в которой хранится имя файла на диске.
  • my_file — файловый объект, представляющий сам файл.
  • my_file_contents — это строка, в которой хранится текст, который находится в файле.

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

  яблоко = "dna.txt"
банан = открытый (яблоко)
grape = banana.read ()  

за исключением того, что это труднее понять! Напротив, имя файла ( dna.txt ) не является произвольным — он должен соответствовать имени файла на жестком диске вашего компьютера.

Распространенная ошибка — попытка использовать метод read () не для того. Напомним, что read () — это метод, который работает только с файловыми объектами. Если мы попытаемся использовать метод read () для имени файла:

  my_file_name = "dna.txt"
my_contents = my_file_name.read ()  

мы получим AttributeError — Python будет жаловаться, что строки не имеют метода read () :

AttributeError: объект ‘str’ не имеет атрибута ‘read’

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

  my_file_name = "dna.txt"
my_file = open (my_file_name)
print (my_file)  

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

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

Работа с символами новой строки

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

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

  # открыть файл
my_file = open ("dna.txt")

# прочитать содержимое
my_dna = my_file.read ()

# рассчитываем длину
dna_length = len (my_dna)

# распечатать вывод
print ("sequence is" + my_dna + "and length is" + str (dna_length))  

Когда мы смотрим на вывод, мы видим, что есть две ошибки.

последовательность ACTGTACGTGCACTGATC и длина 19

Во-первых, вывод был разделен на две строки, хотя мы этого не просили. А во-вторых, неправильная длина — в строке ДНК всего 18 символов.

Обе эти проблемы имеют одинаковое объяснение: Python включил символ новой строки в конец файла dna.txt как часть содержимого. Другими словами, переменная my_dna имеет в конце символ новой строки.Если бы мы могли напрямую просматривать переменную my_dna , мы бы увидели, что она выглядит так:

‘ACTGTACGTGCACTGATC \ n’

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

Решение тоже простое. Поскольку это очень распространенная проблема, у строк есть метод удаления новых строк с их конца.Этот метод называется rstrip () и принимает один строковый аргумент, который является символом, который вы хотите удалить. В этом случае мы хотим удалить символ новой строки ( \ n ). Вот модифицированная версия кода — обратите внимание, что аргумент rstrip () сам по себе является строкой, поэтому его нужно заключить в кавычки: ❶

  my_file = open ("dna.txt")
my_file_contents = my_file.read ()

# удаляем новую строку в конце содержимого файла
my_dna = my_file_contents.rstrip ("\ n") ❶

dna_length = len (my_dna)
print ("sequence is" + my_dna + "and length is" + str (dna_length))  

и теперь результат выглядит так, как мы и ожидали:

Последовательность

ACTGTACGTGCACTGATC и длина 18

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

  my_file_contents = my_file.read ()
my_dna = my_file_contents.rstrip ("\ n")  

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

  my_dna = мой_файл.read (). rstrip ("\ n")  

Поначалу это немного сложно прочитать, поскольку мы используем два разных метода ( read () и rstrip () ) в одном и том же операторе. Ключ заключается в том, чтобы читать его слева направо — мы берем переменную my_file и используем для нее метод read () , затем мы берем результат этого метода (который, как мы знаем, является строкой) и используем rstrip () на нем. Затем результат метода rstrip () сохраняется в переменной my_dna .

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

Отсутствующие файлы

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

  my_file = open ("nonexistent.txt")  

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

IOError: [Errno 2] Нет такого файла или каталога: ‘nonexistent.txt’

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

Запись текста в файлы

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

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

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

Открытие файлов для записи

В предыдущем разделе мы увидели, как открыть файл и прочитать его содержимое. Мы также можем открыть файл и записать в него некоторые данные, но мы должны использовать функцию open () немного по-другому.Чтобы открыть файл для записи, мы используем версию функции open () с двумя аргументами, где второй аргумент — это короткая строка, описывающая, что мы хотим сделать с файлом. Этот второй аргумент может быть «r» для чтения, «w» для записи или «a» для добавления. Если мы опустим второй аргумент (как мы это делали для всех вышеприведенных примеров), Python будет использовать значение по умолчанию для чтения "r" .

Разница между "w" и "a" тонкая, но важная.Если мы откроем уже существующий файл, используя режим «w» , то мы перезапишем текущее содержимое любыми данными, которые мы в него записываем. Если мы откроем существующий файл с режимом "a" , он добавит новые данные в конец файла, но не удалит существующее содержимое. Если файла с указанным именем еще не существует, то "w" и "a" ведут себя одинаково — они оба создадут новый файл для хранения вывода.

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

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

Вот как мы используем open () со вторым аргументом, чтобы открыть файл и записать в него одну строку текста:

  my_file = open ("out.txt", "w")
my_file.write ("Hello world")  

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

Помните, что с write () , как и с print () , мы можем использовать любую строку в качестве аргумента. Это также означает, что мы можем использовать любой метод или функцию, возвращающую строку. Следующее все в порядке:

  # написать "abcdef"
my_file.write ("abc" + "def")

# напишите "8"
my_file.write (str (len ('AGTGCTAG')))

# напишите "TTGC"
my_file.write ("ATGC" .replace ('A', 'T'))

# напишите "atgc"
my_file.write ("ATGC" .lower ())

# записываем содержимое my_variable
мой файл.write (my_variable)  

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

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

  my_file = open ("out.txt", "w")
my_file.write ("Привет, мир")
# не забудьте закрыть файл
my_file.close ()  

Пути и папки

До сих пор мы имели дело только с открытием файлов в той же папке, в которой запущена наша программа. Что, если мы хотим открыть файл из другой части файловой системы?

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

  my_file = open ("c: /windows/Desktop/myfolder/myfile.txt")  

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

Если вы используете компьютер Mac или Linux, путь будет немного другим:

  my_file = open ("/ home / martin / myfolder / myfile.txt")  

Резюме

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

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

Упражнения

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

Расщепление геномной ДНК

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

Запись файла FASTA

Формат файла

FASTA — это широко используемый формат файлов последовательностей ДНК и белков. Одиночная последовательность в формате FASTA выглядит так:

 > имя_последовательности
ATCGACTGATCGATCGTACGAT  

Где имя_последовательности — это заголовок, описывающий последовательность (символ «больше» указывает на начало строки заголовка). Часто заголовок содержит номер доступа, который относится к записи последовательности в общедоступной базе данных последовательностей.Один файл FASTA может содержать несколько последовательностей, например:

 > sequence_one
ATCGATCGATCGATCGAT
> sequence_two
ACTAGCTAGCTAGCATCG
> последовательность_три
ACTGCATCGATCGTACCT  

Напишите программу, которая создаст файл FASTA для следующих трех последовательностей — убедитесь, что все последовательности в верхнем регистре и содержат только основания A, T, G и C.

Заголовок последовательности Последовательность ДНК
ABC123 ATCGTACGATCGATCGATCGCTAGACGTATCG
DEF456 actgatcgacgatcgatcgatcacgact
HIJ789 ACTGAC-ACTGT — ACTGTA —- CATGTG

Запись нескольких файлов FASTA

Используйте данные из предыдущего упражнения, но вместо создания одного файла FASTA создайте три новых файла FASTA — по одному на последовательность.Имена файлов FASTA должны совпадать с именами заголовков последовательностей с расширением .fasta.

Решения

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

.

Работа с текстовым файлом в Python

Переполнение стека
  1. Около
  2. Товары
  3. Для команд
  1. Переполнение стека Общественные вопросы и ответы
  2. Переполнение стека для команд Где разработчики и технологи делятся частными знаниями с коллегами
  3. Вакансии Программирование и связанные с ним технические возможности карьерного роста
  4. Талант Нанимайте технических специалистов и создавайте свой бренд работодателя
  5. Реклама Обратитесь к разработчикам и технологам со всего мира
.