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

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. Работа с данными”.

<<< Python. Урок 11. Работа с исключениями   Python. Урок 13. Модули и пакеты >>>

Файловый ввод-вывод — Pythontutor — статьи

1. Ввод из файла

Пусть нужно считать файл input.txt. Будем считать, что файл input.txt лежит в той же папке, что и наша программа. Напишите в ней такой код:

fin = open('input.txt', 'r')
a = fin.readlines()

После этого в списке a окажется список из строк файла. Например, если файл input.txtбыл

abcd
efgh

то команда print(a) выведет ['abcd\n', 'efgh\n']. Последний символ в каждой строке — '\n' — это один специальный символ конца строки. Обратите внимание: это не два символа, а один.

Можно удалить эти ненужные символы с помощью метода strip(). В этом случае считывание может выглядеть так:

fin = open('input.txt', 'r')
a = [line.strip() for line in fin.readlines()]

2. Вывод в файл

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

fout = open('output.txt', 'w')  # 'w' - это режим "запись" ("write")

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

print("Hello, world!", file=fout)

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

fout.close()

3. Ввод-вывод в ситуации, когда количество строк неизвестно

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

from sys import stdin
a = stdin.readlines()

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

abcd
efgh

то команда print(a) выведет ['abcd\n', 'efgh\n']. Последний символ в каждой строке — '\n' — это один специальный символ конца строки. Обратите внимание: это не два символа, а один.

К сожалению, протестировать на правильность программы с таким вводом-вывом из среды Wing невозможно. Дело в том, что в консоли Винга нельзя сказать, что входной файл закончился. Нет возможности ввести символ конца файла. Соответственно, метод sys.stdin.readlines() никогда не завершится, поскольку будет ждать всё новые и новые строки из входа. Чтобы протестировать ваш код на системе Windows, проделайте следующие действия:

1. Откройте консоль: Пуск → Выполнить → cmd
2. С помощью команды cd дойдите до папки с вашей программой. При этом не стесняйтесь обильно нажимать клавишу Tab.
3. Введите имя вашей программы в консоли и нажмите Enter. При этом ваша программа запустится
4. Введите в консоль входные данные для программы.
5. Введите конец входного файла, нажав сочетание Ctrl+Z. Нажмите Enter.
6. Насладитесь выводом вашей программы.

Python Courses 10. Файловый ввод/вывод. — floppyy blog

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

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

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

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

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

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

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

Также после работы с файлом его необходимо закрыть:

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

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

Теперь прочитаем данные из файла. Для этого сначала откроем файл для чтения. Также как и при записи, все, что нам нужно — указать путь к файлу и флаг ‘r’, обозначающий режим доступа к файлу для чтения:

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

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

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

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

Попробуйте поработать с этой функцией на примере своего файла.

Получение списка строк из файла.

На основе файла можно также создать список строк. Для этого используйте функцию readLines(). Здесь я вернусь к нашему первому файлу и открою его для чтения:

Теперь создадим сам список:

Библиотека codecs. Боремся с кодировками.

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

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

А затем используем схожий со встроенным метод open()  уже из библиотеки codecs, но в качестве дополнительного параметра явно указываем нужную нам кодировку(в данный момент это windows-1251):

В этот раз текст отобразился, как мы и хотели.

Чтение данных из файла и запись в файл

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Базовый поиск файлов Python и ввод-вывод

Я пытаюсь выполнить простую задачу в Python, и я новичок в этом языке (я C++). Надеюсь, кто-нибудь сможет указать мне верное направление.

Проблема:
У меня есть файл XML (12 МБ), полный данных, и внутри файла есть начальные теги ‘xmltag’ и конечные теги ‘/xmltag’, которые представляют начало и конец разделов данных, которые я хотел бы вытащить.

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

Я доволен файловым вводом-выводом, но не самым эффективным циклом, поиском и извлечением данных.

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

Большое спасибо!

python

xml

file

search

text

Поделиться

Источник

user479363    

18 октября 2010 в 14:05

5 ответов

• Tkinter ввод и вывод в одном виджете

  Я пытался создать свой собственный базовый Python IDE. Я создал интерфейс, который содержит текстовое поле ввода, которое позволяет мне вводить синтаксис, и pmw.ScrolledText, который отображает результирующий вывод интерпретатора Python. Что я действительно надеюсь сделать, так это объединить эти…

• python двоичный поиск и файловый ввод-вывод

  Это часть задания, на котором я застрял… Я новичок в python и хочу создать программу, которая будет искать файл, который выглядит так только дольше: Afghanistan, 647500.0, 25500100 Albania, 28748.0, 2821977 Algeria, 2381740.0, 38700000 American Samoa, 199.0, 55519 Как видите, интервал не всегда…

3

Проверка BeautifulSoup

from BeautifulSoup import BeautifulSoup

with open('bigfile.xml', 'r') as xml:
    soup = BeautifulSoup(xml):
    for xmltag in soup('xmltag'):
        print xmltag.contents

Поделиться

eumiro    

18 октября 2010 в 14:08

2

Погружение в Python 3 есть отличная глава об этом:

Это отличная бесплатная книга о python, которую стоит прочитать !

Поделиться

Alois Cochard    

18 октября 2010 в 14:08

1

Ответ BeautifulSoup хорош, но он выполняется быстрее и не требует внешней библиотеки:

import xml. etree.cElementTree as ET
tree = ET.parse('xmlfile.xml')
results = (elem for elem in tree.getiterator('xmltag'))

# in Python 2.7+, getiterator() is deprecated; use tree.iter('xmltag')

Поделиться

ianmclaury    

18 октября 2010 в 15:56

• параллельный файловый ввод-вывод Java

  У меня есть программа Fortran, которая вызывает Java с помощью JNI. Моя функция Java получает массив, записывает массив в файл, делает системный вызов функции Python, которая что-то вычисляет, и записывает результат в файл, который, в свою очередь, считывается функцией Java и передается обратно в…

• Почему Nodejs может выполнять асинхронный ввод-вывод файлов, а Python asyncio-нет?

  Недавно я хотел использовать Python async/await на локальном файле IO, однако я нахожу это невозможным после прочтения следующих ссылок: Поддерживает ли asyncio асинхронный ввод-вывод для файловых операций? Читать файл построчно с ввода-вывода Решение — это модули aiofiles, которые основаны на…

0

Нет необходимости устанавливать BeautifulSoup, Python включает парсер ElementTree в свою стандартную библиотеку.

from xml.etree import cElementTree as ET
tree = ET.parse('myfilename')
new_tree = ET('new_root_element')
for element in tree.findall('.//xmltag'):
    new_tree.append(tree.element)
print ET.tostring(new_tree)

Поделиться

Daniel Roseman    

18 октября 2010 в 15:48

-2

xml=open("xmlfile").read()
x=xml.split("</xmltag>")
for block in x:
    if "<xmltag>" in block:
        print block.split("<xmltag>")[-1]

Поделиться

ghostdog74    

18 октября 2010 в 14:11

Похожие вопросы:

Как создать базовый семантический поиск в python

Я хочу написать базовый семантический веб-искатель с использованием Python, я знаю, что семантические приложения используют RDF файлов, но что еще? У меня установлено несколько модулей Python RDF, и…

Стандартный ввод и вывод в .NET

Как я могу читать со стандартного ввода и записывать на стандартный вывод? Ссылка System.Diagnostics.Process.StandardInput MSDN не помогла, так как она отдельно запускает процесс, а затем…

Python ввод и вывод скрипта в excel

После полудня, У меня есть очень простой скрипт python, в котором пользователю предлагается ввести цену покупки акций, скрипт ищет цену и возвращает, является ли пользователь вверх или вниз. В…

Tkinter ввод и вывод в одном виджете

Я пытался создать свой собственный базовый Python IDE. Я создал интерфейс, который содержит текстовое поле ввода, которое позволяет мне вводить синтаксис, и pmw.ScrolledText, который отображает…

python двоичный поиск и файловый ввод-вывод

Это часть задания, на котором я застрял… Я новичок в python и хочу создать программу, которая будет искать файл, который выглядит так только дольше: Afghanistan, 647500.0, 25500100 Albania,…

параллельный файловый ввод-вывод Java

У меня есть программа Fortran, которая вызывает Java с помощью JNI. Моя функция Java получает массив, записывает массив в файл, делает системный вызов функции Python, которая что-то вычисляет, и…

Почему Nodejs может выполнять асинхронный ввод-вывод файлов, а Python asyncio-нет?

Недавно я хотел использовать Python async/await на локальном файле IO, однако я нахожу это невозможным после прочтения следующих ссылок: Поддерживает ли asyncio асинхронный ввод-вывод для файловых…

Python3-curses ввод / вывод через сетевой сокет?

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

Чистые функции и ввод-вывод

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

Вывод с адресом файлов (Python)

Я новичок python, и мне нужна помощь с одной проблемой. Мне нужен код, в который я вставляю папку, содержащую jpeg файлов, и мой вывод-это адрес расположения всех файлов, содержащихся в этой папке….

Ввод-вывод файлов Python: упражнения, практика, решение

Последнее обновление 26 июля 2019 09:06:47 (UTC / GMT +8 часов)

script1adsense2code

script1adsense3code

Python File Input Output [17 упражнений с решением]

[ Внизу страницы доступен редактор для написания и выполнения сценариев. ]

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

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

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

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

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

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

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

8. Напишите программу на python, чтобы найти самые длинные слова. Перейти к редактору
Нажмите меня, чтобы увидеть образец решения

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

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

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

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

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

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

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

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

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

Редактор кода Python:

Еще не все !

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

Файловый ввод вывод python

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

Что такое файл?

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

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

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

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

Как открыть файл?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Запись в файл

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

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

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

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

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

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

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

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

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

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

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

Методы работы с файлами в Python

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

7. Итерация

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

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

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

8. Pickling

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Заключение

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

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

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

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

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

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

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

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

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

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

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

Запись в файл

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

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

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

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

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

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

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

Python Input Output (I / O) Использование функций input () и print ()

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

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

Вывод Python с использованием функции print ()

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

Пример его использования приведен ниже.

  print ('Это предложение выводится на экран')  

Выход

  Это предложение выводится на экран  

Другой пример приведен ниже:

  а = 5
print ('Значение a равно', a)  

Выход

  Значение a равно 5  

Во втором операторе print () мы можем заметить, что между строкой и значением переменной a был добавлен пробел.Это по умолчанию, но мы можем это изменить.

Фактический синтаксис функции print () :

print (* объекты, sep = '', end = '\ n', file = sys.stdout, flush = False) 

Здесь объектов — это значение (я) для печати.

Между значениями используется разделитель sep . По умолчанию используется пробел.

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

Файл — это объект, в котором печатаются значения, и его значение по умолчанию — sys.stdout (экран). Вот пример, чтобы проиллюстрировать это.

  печать (1, 2, 3, 4)
печать (1, 2, 3, 4, sep = '*')
печать (1, 2, 3, 4, sep = '#', end = '&')  

Выход

  1 2 3 4
1 * 2 * 3 * 4
1 # 2 # 3 # 4 и  

Форматирование вывода

Иногда нам нужно отформатировать наш вывод, чтобы он выглядел привлекательно. Это можно сделать с помощью метода str.format () . Этот метод виден любому строковому объекту.

  >>> х = 5; у = 10
>>> print ('Значение x равно {}, а y равно {}'. format (x, y))
Значение x равно 5, а y равно 10  

.

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

  print ('Я люблю {0} и {1}'. Format ('хлеб', 'масло'))
print ('Я люблю {1} и {0}'. format ('хлеб', 'масло'))  

Выход

  Я люблю хлеб с маслом
Я люблю масло и хлеб  

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

  >>> print ('Привет, {имя}, {приветствие}'. Format (welcome = 'Goodmorning', name = 'John'))
Привет, Джон, доброе утро  

Мы также можем форматировать строки, как в старом стиле sprintf () , используемом в языке программирования C. Для этого мы используем оператор % .

  >>> х = 12,3456789
>>> print ('Значение x равно% 3.2f'% x)
Значение x равно 12,35.
>>> print ('Значение x равно% 3.4f'% x)
Значение x равно 12.3457  

Ввод Python

До сих пор наши программы были статичными. Значение переменных было определено или жестко закодировано в исходном коде.

Чтобы обеспечить гибкость, мы можем захотеть получить ввод от пользователя. В Python для этого есть функция input () . Синтаксис для input () :

ввод ([подсказка]) 

, где подсказка — строка, которую мы хотим отобразить на экране. Это необязательно.

  >>> num = input ('Введите число:')
Введите число: 10
>>> число
'10'  

Здесь мы видим, что введенное значение 10 является строкой, а не числом. Чтобы преобразовать это в число, мы можем использовать функции int () или float () .

  >>> целое ('10 ')
10
>>> float ('10 ')
10,0  

Эту же операцию можно выполнить с помощью функции eval () . Но eval идет дальше.Он может вычислять даже выражения, если на входе строка

  >>> интервал ('2 + 3')
Отслеживание (последний вызов последний):
  Файл «<строка>», строка 301, в коде выполнения
  Файл «<интерактивный ввод>», строка 1, в <модуле>
ValueError: недопустимый литерал для int () с базой 10: '2 + 3'
>>> eval ('2 + 3')
5  

Python Импорт

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

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

Определения внутри модуля можно импортировать в другой модуль или интерактивный интерпретатор в Python. Для этого мы используем ключевое слово import .

Например, мы можем импортировать модуль math , набрав следующую строку:

  импорт математики  

Мы можем использовать модуль следующими способами:

  импорт математики
печать (math.pi)  

Выход

  3.1415589793  

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

  >>> from math import pi
>>> пи
3,1415589793  

При импорте модуля Python просматривает несколько мест, определенных в sys.path . Это список расположений каталогов.

  >>> import sys
>>> sys.дорожка
['',
 'C: \ Python33 \ Lib \ idlelib',
 'C: \ Windows \ system32 \ python33.zip',
 'C: \ Python33 \ DLLs',
 'C: \ Python33 \ lib',
 'C: \\ Python33',
 'C: \ Python33 \ lib \ site-packages']  

Мы также можем добавить в этот список наше собственное местоположение.

Обработка файлов в Python - GeeksforGeeks

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

Работа функции open ()

Мы используем функцию open () в Python для открытия файла в режиме чтения или записи.Как объяснялось выше, open () вернет файловый объект. Чтобы вернуть объект файла, мы используем функцию open () вместе с двумя аргументами, которые принимают имя файла и режим, читать или писать. Итак, синтаксис: open (имя файла, режим) . Python предоставляет три режима и способы открытия файлов:

• « r », для чтения.
• « w », для письма.
• « a », для добавления.
• « r + », как для чтения, так и для записи

Следует иметь в виду, что аргумент режима не является обязательным.Если не передано, Python по умолчанию примет значение « r ». Давайте посмотрим на эту программу и попробуем проанализировать, как работает режим чтения:

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

Работа в режиме чтения ()

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

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

Создание файла с использованием режима write ()

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

Команда close () завершает работу всех используемых ресурсов и освобождает систему от этой конкретной программы.

Работа режима append ()

Давайте посмотрим, как работает режим добавления:

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

 rstrip (): Эта функция удаляет каждую строку файла из пробелов с правой стороны.
lstrip (): эта функция удаляет каждую строку файла с левой стороны.

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

Использование записи вместе с функцией with ()

Мы также можем использовать функцию записи вместе с функцией ():

902 split () с использованием обработки файлов

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

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

Автор статьи: Chinmoy Lenka . Если вам нравится GeeksforGeeks, и вы хотели бы внести свой вклад, вы также можете написать статью на сайте deposit.geeksforgeeks.org или отправить свою статью по почте @ geeksforgeeks.орг. Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам.

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

Работа с файловым вводом-выводом в 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 (имя файла, режим)
 

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

Вы также можете указать точный путь к файлу, например «C: \ ThisFolder \ workData.txt », если вы используете Windows.

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

К счастью, у Python есть два способа справиться с этим. Первый - использовать двойную обратную косую черту, например: "C: \\ ThisFolder \\ workData.txt" . Второй - использовать косую черту: "C: /ThisFolder/workData.txt" .

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

• 'w' - режим записи : этот режим используется, когда необходимо изменить файл и изменить или добавить информацию. Имейте в виду, что при этом будет удален существующий файл для создания нового. Указатель файла помещается в начало файла.
• 'r' - Режим чтения : Этот режим используется, когда информация в файле предназначена только для чтения и никоим образом не изменяется.Указатель файла помещается в начало файла.
• 'a' - Режим добавления : Этот режим автоматически добавляет информацию в конец файла. Указатель файла помещается в конец файла.
• 'r +' - Режим чтения / записи : используется, когда вы будете вносить изменения в файл и читать информацию из него. Указатель файла помещается в начало файла.
• 'a +' - Режим добавления и чтения : файл открывается, чтобы разрешить добавление данных в конец файла, а также позволяет вашей программе читать информацию.Указатель файла помещается в конец файла.

Когда вы используете двоичные файлы, вы будете использовать те же спецификаторы режима. Однако вы добавляете в конец букву b. Таким образом, спецификатор режима записи для двоичного файла - 'wb' . Остальные: 'rb' , 'ab' , 'r + b' и 'a + b' соответственно.

В Python 3 добавлен один новый режим:

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

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

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

 data_file = open ("workData.txt", "r +")
 

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

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

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

Когда вы читаете и пишете, важно знать, как закрыть файл.

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

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

Функция закрытия файла в Python - это просто fileobject.close () . Используя файловый объект data_file , который мы создали в предыдущем примере, команда для его закрытия будет:

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

 >>> f = open ("/ tmp / myfile.txt", "w")
>>> f.close ()
>>> f.read ()
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
    f.read ()
ValueError: операция ввода-вывода для закрытого файла.
 

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

 с открытым ("workData.txt "," r + ") как workData:
    # Файловый объект теперь открыт.
    # Что делать с файлом:
    workData.read ()

# Файловый объект закрыт.
# Делай другие дела ...
 

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

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

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

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

Далее вы узнаете, как считывать данные из открытого файла:

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

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

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

Параметр size сообщает методу чтения, сколько байтов в файле нужно вернуть на дисплей. Итак, предположим, что в нашем файле workData.txt есть следующий текст:

 Эти данные находятся в строке 1
Эти данные находятся в строке 2
Эти данные находятся в строке 3
 

Тогда, если вы написали следующую программу на Python 3:

 с open ("workData.txt", "r +") как work_data:
    print ("Это имя файла:", work_data.name)
    line = work_data.read ()
    печать (строка)
 

Вы получите следующий результат:

 Это имя файла: workData.текст
Эти данные находятся в строке 1
Эти данные находятся в строке 2
Эти данные находятся в строке 3
 

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

Вы получите следующий результат:

 Это имя файла: workData.txt
Это д
 

Как видите, операция чтения считывает данные в файле только до позиции 6 , которую мы передали в вызов read () выше. Таким образом вы можете ограничить объем данных, считываемых из файла за один раз.

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

Построчное чтение текстовых файлов с помощью строки чтения

()

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

Метод fileobject.readline (size) по умолчанию возвращает первую строку файла. Но изменив целочисленный параметр size , вы можете получить любую нужную строку в своем файле.

Например:

 с open ("workData.txt", "r +") как work_data:
     print ("Это имя файла:", work_data.name)
     line_data = work_data.readline ()
     печать (данные_строки)
 

Это вернет результат:

 Это имя файла: workData.txt
Эти данные находятся в строке 1
 

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

Аналогичным методом является вызов fileobject.readlines () (обратите внимание на множественное число), который возвращает список всех строк в файле.Если вы звонили по номеру:

 печать (work_data.readlines ())
 

Вы получите следующий результат:

 ['Эти данные находятся в строке 1', 'Эти данные находятся в строке 2', 'Эти данные находятся в строке 3']
 

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

Построчная обработка всего текстового файла

Самый простой способ построчно обработать весь текстовый файл в Python - использовать простой цикл:

 с открытым ("workData.txt "," r + ") как work_data:
    для строки в work_data:
        печать (строка)
 

Это дает следующий результат:

 Эти данные находятся в строке 1
Эти данные находятся в строке 2
Эти данные находятся в строке 3
 

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

Запись в файл с помощью Python с использованием

write ()

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

Помните, что когда вы создаете новый файловый объект, Python создаст файл, если он еще не существует. При создании файла в первый раз следует использовать режимы a + или w + .

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

По умолчанию для записи в файл в Python используется метод fileobject.write (data) . Например, вы можете добавить новую строку в наш файл «workData.txt», используя следующий код:

 work_data.write («Эти данные находятся в строке 4 \ n»)
 

\ n действует как индикатор новой строки, перемещая последующие записи на следующую строку.

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

Например, если вы хотите добавить целые числа 1234, 5678, 9012 в файл work_data , вы должны сделать следующее. Сначала вы преобразуете свои не-строки в строку, затем вы записываете эту строку в свой файловый объект:

Значения

 = [1234, 5678, 9012]

с open ("workData.txt", "a +") как work_data:
    для значения в значениях:
        str_value = str (значение)
        work_data.написать (str_value)
        work_data.write ("\ n")
 

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

Помните, что когда вы пишете в режиме a + , указатель файла всегда будет в конце файла. Итак, взяв приведенный выше код, где мы записали два числа, если вы используете метод fileobject.write () , вы ничего не получите взамен. Это потому, что этот метод ищет указатель, чтобы найти дополнительный текст.

Что вам нужно сделать, так это переместить указатель обратно в начало файла. Самый простой способ сделать это - использовать метод fileobject.seek (offset, from_what) . В этом методе вы помещаете указатель в определенное место.

Смещение - это количество символов из параметра from_what . Параметр from_what имеет три возможных значения:

• 0 - указывает начало файла
• 1 - указывает текущую позицию указателя
• 2 - указывает конец файла

Когда вы работаете с текстовыми файлами (теми, которые были открыты без ab в режиме), вы можете использовать только значение по умолчанию 0 или seek (0, 2) , что приведет вас к конец файла.

Итак, используя work_data.seek (3, 0) в нашем файле «workData.txt», вы поместите указатель на 4-й символ (помните, что Python начинает отсчет с 0). Если вы используете цикл строчной печати, вы получите результат:

 с данные в строке 1
Эти данные находятся в строке 2
Эти данные находятся в строке 3
 

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

 с открытым ("workData.txt", "a +") как work_data:
    печать (work_data.tell ())
 

Это даст возвращаемое значение 69, что является размером файла.

Редактирование существующего текстового файла с помощью Python

Придет время, когда вам нужно будет отредактировать существующий файл, а не просто добавить к нему данные. Для этого нельзя просто использовать режим w + . Помните, что режим w полностью перезапишет файл, поэтому даже при использовании fileobject.seek () , вы не сможете этого сделать. И a + всегда будет вставлять любые данные в конец файла.

Самый простой способ сделать это - вытащить весь файл и создать с ним список или массив данных. После создания списка вы можете использовать метод list.insert (i, x) для вставки новых данных. После создания нового списка вы можете снова объединить его и записать обратно в свой файл.

Помните, что для списка .insert (i, x) , i - целое число, обозначающее номер ячейки. Затем данные x помещаются перед ячейкой в ​​списке, обозначенной цифрами i .

Например, используя наш файл «workData.txt», допустим, нам нужно вставить текстовую строку «Это между строками 1 и 2» между первой и второй строками. Код для этого:

 # Открыть файл только для чтения
с open ("workData.txt", "r") как work_data:
    work_data_contents = work_data.readlines ()

work_data_contents.insert (1, "Это находится между строками 1 и 2 \ n")

# Повторно открыть в формате только для записи, чтобы перезаписать старый файл
с open ("workData.txt", "w") как work_data:
    work_dataContents = "" .join (work_data_contents)
    work_data.write (work_data_contents)
 

После запуска этого кода, если вы сделаете следующее:

 с open ("workData.txt", "r") как work_data:
    для строки в work_data:
        печать (строка)
 

Вы получите результат:

 Эти данные находятся в строке 1
Это идет между строками 1 и 2
Эти данные находятся в строке 2
Эти данные находятся в строке 3
 

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

Python File I / O - Дополнительные ресурсы

В этом руководстве вы изучили основы работы с файлами в Python. Мы рассмотрели следующие темы:

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

Но на самом деле мы коснулись здесь только поверхности.Как и во всем, что связано с программированием, здесь есть чему поучиться…

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

Python File I / O - чтение и запись файлов в Python

Встроенные функции Python input () и print () выполняют операции чтения / записи со стандартными потоками ввода-вывода. Функция input () считывает текст в переменные памяти с клавиатуры, которая определяется как sys.stdin, а функция print () отправляет данные на устройство отображения, идентифицированное как sys.стандартный вывод. Модуль sys представляет определения этих объектов.

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

Функция open ()

Объект File возвращается функцией open (), которой требуется имя файла вместе с его путем и режимом открытия файла.

 файл = открытый (имя, режим) 

Параметр режима определяет, как следует обрабатывать файл. Режим по умолчанию - «r», что означает, что теперь можно читать данные из файла. Для хранения данных в нем параметр режима должен быть установлен на «w». Другие поддерживаемые значения параметра режима и их значение перечислены в следующей таблице:

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

Метод write ()

Следующий оператор открывает python.txt в режиме записи.

 >>> f = open ("python.txt", "w") 

Затем мы должны поместить определенные данные в файл. Метод write () сохраняет строку в файле.

 >>> f.write (("Летающий цирк Монти Пайтона") 

Убедитесь, что вы закрыли объект файла в конце.

 >>> f.close () 

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

Метод writeelines ()

Объект файла также имеет метод Writelines () для записи элементов из объекта списка в файл. Символы новой строки («\ n) должны быть частью строки.

lines = [« Красивое лучше, чем уродливое. \ N »,« Явное лучше, чем неявное. \ N »,« Простое лучше, чем сложное. \ n "," Сложный лучше, чем сложный. \ n "]

 f = open (" python.txt "," w ")
f.writelines (строки)
f.close () 

В файле python.txt показаны следующие данные.При открытии в редакторе.

 Красивое лучше уродливого.
Явное лучше, чем неявное.
Лучше простое, чем сложное.
Сложный лучше, чем сложный. 

Метод чтения ()

Чтобы прочитать данные из файла, нам нужно открыть его в режиме «r».

 >>> f = open ('python.txt', 'r') 

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

 >>> f.читать (9)
'Beautiful' 

Метод readline ()

Этот метод считывает текущую строку до тех пор, пока не встретит символ новой строки.

 >>> f = open ('python.txt', 'r')
>>> f.readline ()
'Красивое лучше, чем уродливое. \ N' 

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

 f = open ("python.txt", "r")
в то время как True:
line = f.readline ()
если строка == '': разрыв
печать (строка)
f.close () 

Метод readlines ():

Этот метод считывает все строки и возвращает объект списка.

 >>> f = open ('python.txt', 'r')
>>> f.readlines ()
['Красивое лучше, чем уродливое. \ N', 'Явное лучше, чем неявное. \ N', 'Простое лучше, чем сложное. \ N', 'Сложное лучше, чем сложное. \ N'] 

Исключение в Обработка файлов

Работа с файлами может быть исключительной. Если файл не может быть открыт, возникает ошибка OSError, а если она не найдена, возникает ошибка FileNotFoundError.

 >>> f = open ("anyfile.txt "," r ")
Отслеживание (последний вызов последний):
Файл "", строка 1, в 
f = open ("anyfile.txt", "r")
FileNotFoundError: [Errno 2] Нет такого файла или каталога: 'anyfile.txt' 

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

 попробуйте:
f = open ("python.txt", "r")
в то время как True:
line = f.readline ()
если строка == '': разрыв
печать (строка, конец = '')
кроме FileNotFoundError:
print («Файл не найден»)
еще:
f.close () 

Файловый объект как итератор

Файловый объект - это поток данных, который поддерживает метод next () для чтения файла построчно. Когда обнаруживается конец файла, возникает исключение StopIteration.

 f = open ("python.txt", "r")
в то время как True:
пытаться:
строка = следующий (е)
печать (строка, конец = "")
кроме StopIteration:
перерыв
f.close () 

Вывод:

 Красивое лучше уродливого.Явное лучше, чем неявное.
Лучше простое, чем сложное.
Сложный лучше, чем сложный. 

режим добавления

Когда файл открывается в режиме «w», его содержимое удаляется, если оно уже существует. Чтобы добавить больше данных в существующий файл, используйте режим «a» (режим добавления).

 f = open ("python.txt", "a") 

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

 >>> f = open ('python.txt', 'a')
>>> е.write ("Плоский лучше, чем вложенный. \ n")
28 год
>>> f.close () 

В конце файла будет дополнительная строка.

+ режим для одновременного чтения / записи

Режим «w» или режим «a» позволяет записывать данные, но не из них чтение. С другой стороны, режим «r» разрешает только чтение, но не разрешает операцию записи. Для одновременного выполнения операций чтения / записи используйте режим «r +» или «w +».

Метод seek ()

Метод seek () файлового объекта устанавливает текущую позицию чтения / записи в указанное место в файле.

 f.seek (смещение, откуда) 

Здесь параметр откуда подсчитывает смещение от начала, текущей позиции или конца соответственно:

• 0: смещение, вычисленное с начала
• 1: смещение, вычисленное с текущей позиции
• 2: смещение рассчитывается с конца.

Предположим, что python.txt содержит следующие строки.

 Красивое лучше уродливого.
Явное лучше, чем неявное. 

Теперь мы пытаемся заменить слово «лучше» на «всегда лучше».Сначала откройте файл в режиме чтения / записи. Поместите указатель файла в начало 2-й строки и прочтите его. Замените «лучше» на «всегда лучше» и перепишите строку.

Код:

 f = open ("python.txt", "r +")
f.seek (32,0)
s = f.readline ()
s = s.replace ('есть', 'всегда')
печать (и)
f.seek (32,0)
е. напишите (и)
f.seek (0,0)
lines = f.readlines ()
для строки в строках:
печать (строка)
f.close () 

Вывод:

 Красивое лучше уродливого.Явное всегда лучше, чем неявное. 

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

Функция open () по умолчанию открывает файл в текстовом формате. Чтобы открыть файл в двоичном формате, добавьте «b» в параметр режима. Следовательно, режим «rb» открывает файл в двоичном формате для чтения, а режим «wb» открывает файл в двоичном формате для записи. В отличие от файлов текстового режима, двоичные файлы не читаются человеком. При открытии с помощью любого текстового редактора данные невозможно распознать.

Следующий код сохраняет число в двоичном файле.Перед записью он сначала конвертируется в байты. Функция to_bytes () класса int возвращает байтовое представление объекта.

 f = открытый ('число', 'wb')
d = 1024
f.write (int.to_bytes (d, 16, 'большой'))
f.close () 

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

 f = открытый ('число', 'wb')
d = 1024
f.write (int.to_bytes (d, 16, 'большой'))
f.close () 

Атрибуты файла:

Помимо вышеуказанных методов, файловый объект также характеризуется следующими атрибутами:

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

Обзор

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

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

Функция open открывает файл. Это просто. Это первый шаг в чтении и записи файлов на Python.

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

Например, атрибут mode файлового объекта сообщает вам, в каком режиме был открыт файл. А атрибут name сообщает вам имя файла, который объект файла открылся.

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

Типы файлов

То, что вы можете знать как файл, в Python немного отличается.

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

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

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

Каждая строка заканчивается специальным символом, который называется EOL или . Конец строки . Есть несколько типов, но наиболее распространенными являются запятая {,} или символ новой строки. Он завершает текущую строку и сообщает интерпретатору, что началась новая.

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

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

Функция открытия ()

Чтобы начать чтение и запись файлов в python, вы должны полагаться на встроенную функцию python open file. Используйте open (), чтобы открыть файл в Python.

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

Рекомендуемое обучение Python

Для обучения Python наша главная рекомендация - DataCamp.

Аргумент - это не что иное, как значение, предоставленное функции, которое передается, когда вы ее вызываете. Так, например, если мы объявим имя файла как «Тестовый файл», это имя будет считаться аргументом.

Синтаксис для открытия файлового объекта в Python:

    файл_   объект   =   открыть (  «  имя файла  »  ,   «  режим  »  ) 690 переменная где файл для добавления файлового объекта. 

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

Режим

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

Режимы:

• ‘ r ’ - файл чтения Python.Режим чтения, который используется, когда файл только читается
• ‘ w ’ - файл записи Python. Режим записи, который используется для редактирования и записи новой информации в файл (все существующие файлы с тем же именем будут удалены при активации этого режима)
• ‘ a ’ - файл добавления Python. Режим добавления, который используется для добавления новых данных в конец файла; то есть новая информация автоматически дополняется до конца
• ‘ r + ’ - специальный режим чтения и записи, который используется для обработки обоих действий при работе с файлом

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

    F = открытый («рабочий файл», «w»)  
   Печать f    

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

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

Python записать в файл

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

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

Однако для целей этого руководства мы будем называть новый файл «testfile.txt».

После создания нового файла он будет пустым.Следующим шагом является добавление содержимого с помощью метода записи python.

Чтобы управлять файлом, напишите в своей среде Python следующее (вы можете скопировать и вставить, если хотите):

    file = open («testfile.txt», «w»)  
    
   file.write («Привет, мир»)  
   file.write («Это наш новый текстовый файл»)  
   file.write («а это еще одна строка.»)  
   файл.напишите («Почему? Потому что мы можем»)  
    
   file.close ()    

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

    $ cat testfile.txt  
   Привет, мир  
   Это наш новый текстовый файл  
   а это еще одна строка. 
   Почему? Потому что мы     можем.  
  

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

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

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

    file.read ()    

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

    файл =   открытый (  «  тестовый файл.txt   ” ,  “   r   ”)  
   распечатать   файл. Прочитать   ()    

Убедитесь, что у вас правильный путь к файлу, будь то относительный путь или абсолютный путь, иначе ваша программа python не сможет открыть файл. Результат этой команды будет отображать весь текст внутри файла, тот же текст, который мы сказали интерпретатору добавить ранее. Нет необходимости переписывать все это заново, но если вам нужно знать, будет показано все, кроме «$ cat testfile.txt ».

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

Например, с помощью следующего кода интерпретатор прочитает первые пять символов сохраненных данных и вернет их в виде строки:

    файл =   открытый (  «testfile.txt», «r»)

   распечатать   файл. Прочитать   (5)      

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

Результат будет выглядеть так:

    Привет    

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

Зачем вам использовать что-то подобное?

Допустим, вы хотите видеть только первую строку файла или третью. Вы должны выполнить функцию readline ( ) столько раз, сколько возможно, чтобы получить данные, которые вы ищете.

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

    файл =   открытый (  «  testfile.txt  »  ,   «  r  »  )  
   печать   file.readline   ():    

Это вернет первую строку файла, например:

    Привет, мир    

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

    файл =   открытый (  «  тестовый файл.txt   ” ,  “   r   ” )  
   печать   file.readline   (3):    

Но что, если бы мы хотели вернуть каждую строку в файле, разделенную должным образом? Вы бы использовали ту же функцию, только в новой форме. Это называется функцией file.readlines () .

    f   ile =   open (  “  testfile.txt   ” ,  “   r   ” )  
   p   rint   file.readlines   ()    

В результате вы получите:

    [«Hello World», «Это наш новый текстовый файл», «и это еще одна строка». «Почему? Потому что мы можем. »]    

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

Цикл по файловому объекту

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

    f   ile =   open (  “  testfile.txt   ” ,  “   r   ” )  
   f   или строка в файле:  
   p   линия обтекания,    

Это вернет:

    Привет, мир  
   Это наш новый текстовый файл  
   а это еще одна строка.  
   Почему? Потому что мы можем.    

Видите, насколько это проще предыдущих методов?

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

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

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

    f   ile =   open (  «testfile.txt», «w»)
 
  f   ile.write   («Это тест») 
  f   ile.write   («Чтобы добавить больше строк.»)
 
  f   ile.close   ()    

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

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

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

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

Обратите внимание, как мы использовали это в нескольких наших примерах для завершения взаимодействия с файлом? Это хорошая практика.

Обработка файлов в Python

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

Открытие текстового файла:

    fh   =   open (  «привет.txt »,« r »)    

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

    Fh   =   открытый (  «hello.txt», «r»)  
   печать   fh.read   ()    

Чтобы читать текстовый файл по одной строке за раз:

    fh   =   open (  «  hello.text  », «r»)  
   печать   fh.readline   ()    

Чтобы прочитать список строк в текстовом файле:

    fh   =   открытый (  «hello.txt», «r»)  
   печать   fh.readlines   ()    

Чтобы записать новый контент или текст в файл:

    fh   =   открытый (  «hello.txt», «w»)  
  
   fh.напишите   («  Поместите сюда текст  , который вы хотите добавить»)  
   fh.write   («и больше строк, если необходимо»)  
  
   fh.close   ()    

Вы также можете использовать это для одновременной записи нескольких строк в файл (пример новой строки python):

    f   h   = open («  hello.txt»  , «w  »)  
   l   ines_of_text   = [«Одна строка текста здесь \ n», «и другая строка здесь \ n», «и еще одна здесь \ n», «и так далее и тому подобное»]  
   f   h.Writelines   (  lines_of_text  )  
   f   h. Закрыть   ()    

Чтобы добавить файл:

    fh   =   открытый (  «hello.txt», «a»)  
   fh.write   («Мы снова встретимся, мир»)  
   fh.close    

Чтобы полностью закрыть файл, когда вы закончите:

    f   h   =   открыто (  «привет.txt »,« r »)  
   p   rint   fh.read   ()  
   f   h. Закрыть   ()    

с заявлением

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

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

Чтобы использовать оператор with для открытия файла:

    с открытым («имя файла») как файл:    

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

    w   с открытым («testfile.txt») как файл:  
   d   ata =   file.read   ()  
   d   или что-то с данными    

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

   w  с открытым («testfile.txt») как f:  
   f   или строка в f:  
   p   линия обтекания,    

Вы также заметите, что в приведенном выше примере мы не использовали метод « file.close () », потому что оператор with автоматически вызывает его при выполнении. Это действительно делает вещи намного проще, не так ли?

Использование оператора With в Python

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

Для записи в файл с помощью оператора with:

    с открытым   (  «hello.txt», «w») как f:  
   f.write   («Hello World»)    

Чтобы прочитать файл построчно, выведите в список:

    w   с открытым («hello.txt») как f:  
   d   ata =   f. Строки чтения   ()    

Это займет весь текст или содержимое из «hello.txt »и сохраните его в строке с именем« data ».

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

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

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

Код для этого (также с использованием оператора with):

    с открытым   (  «  hello.text  », «r») как f:  
   data =   f.readlines   ()  
  
   для строки в данных:  
   слова =   line.split   ()  
   печатные слова    

Если вы хотите использовать двоеточие вместо пробела для разделения текста, вы просто измените строку.split () в line.split («:»).

Результатом будет:

    [«привет», «мир», «как», «есть», «вы», «сегодня?»]  
   [«сегодня», «будет», «суббота»]    

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

Подробнее о прочтении

Официальная документация Python - чтение и запись файлов

Шпаргалка по работе с файлами Python

Рекомендуемое обучение Python

Для обучения Python наша главная рекомендация - DataCamp.

Ввод и вывод файлов - Учебник по вычислительной биологии

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

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

Чтобы использовать дескриптор файла в Python, мы должны сообщить интерпретатору, что мы хотим использовать некоторые функции ввода / вывода, сначала поместив специальную команду import io в верхнюю часть нашей программы. Эта команда импортирует модуль io , делая доступными дополнительные функции, существующие в нем. Эти функции также используют точечный синтаксис для указания модуля, в котором они существуют, что до степени смешения похоже на точечный синтаксис, обсуждавшийся ранее для методов.Чтобы связать дескриптор файла с именем fhandle с файлом « filename.txt» , например, команда: fhandle = io.open («filename.txt», «rU») , где open () - это функция в импортированном модуле io . r указывает, что мы создаем дескриптор файла, доступный только для чтения, а U сообщает интерпретатору, что нам нужна «универсальная» интерпретация символов новой строки, чтобы разрешить чтение файлов, созданных в системах Microsoft Windows или Unix-подобных системах.Тип данных дескриптора файла имеет метод .readline () , который возвращает следующую доступную строку из конвейера в виде строки; Итак, line = fhandle.readline () извлекает строку (строку) из дескриптора файла и присваивает ее строке .

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

Теперь давайте создадим программу, которая считывает и распечатывает данные. Когда мы закончим чтение данных из файла, нам нужно запустить дескриптор файла .close () метод. Использование .close () заставляет дескриптор файла предупреждать операционную систему о том, что мы закончили чтение данных из дескриптора. На этом этапе операционная система может удалить внутренний «канал» и любые данные, которые могут в нем находиться.

Если файл не существует или не может быть прочитан программой, вы получите IOError с указанием Нет такого файла или каталога или Permission denied с именем файла, которое вы пытались открыть.Поскольку наш файл существует, мы можем успешно выполнить код и проверить результаты:

Здесь следует отметить несколько моментов. Во-первых, каждый раз, когда мы вызываем fhandle.readline () , дескриптор файла возвращает другую строку: следующую строку, ожидающую извлечения из конвейера. Во-вторых, мы видим, что вывод содержит наши три строки, но разделены пустыми строками: это потому, что в файле уже есть символы «новой строки». Мы не видим этих символов новой строки, но мы можем представить их сами, если захотим, в строке с контрольным кодом \ n .Точно так же символы табуляции имеют управляющий код, например \ t . На самом деле файл представляет собой одну последовательную строку, и метод .readline () просит дескриптор файла вернуть все, вплоть до следующего \ n .

В конце концов, причина появления пустых строк в нашем выводе заключается в том, что функция print () для нашего удобства добавляет \ n в конец любой строки, которую мы печатаем (в противном случае большая часть нашего вывода все будут на одной линии).Таким образом, каждая строка, считанная из файла, печатается с двумя \ n символами. Мы узнаем, как печатать без дополнительной новой строки, позже, когда научимся записывать данные в файлы. На данный момент мы решим проблему, удалив начальные и конечные пробелы (пробелы, табуляции и символы новой строки), попросив строку запустить ее метод .strip () .

Хотя мы снова вызываем import io , это просто для ясности: программе нужно импортировать модуль только один раз (и обычно они собираются в верхней части программы).Вот измененный результат:

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

Чтобы связать это с более ранними концепциями, после того, как мы извлекли каждую строку и удалили завершающие пробелы, мы можем использовать .split ("\ t") для разделения каждой строки на список строк. Оттуда мы можем использовать float () для преобразования второго элемента каждого в тип с плавающей запятой и вычисления среднего содержания GC.

Выше показано среднее содержание GC в трех строках как 0,523333333 . (Поскольку .strip () также возвращает строку, мы могли бы иметь дополнительные связанные методы, как в line1_list = fhandle.readline (). Strip (). Split ("\ t") .)

Поскольку дескрипторы файлов работают как конвейер, они не допускают «произвольный доступ»; мы можем получить следующий бит данных из конца конвейера, но это все. Можно подумать, что команда типа line5 = fhandle [4] будет работать, но вместо этого она выдаст ошибку типа TypeError: '_io.Объект BufferedReader не имеет атрибута __getitem__ .

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

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

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

Запись данных в файл работает почти так же, как и чтение данных: мы открываем дескриптор файла (который снова работает как канал) и вызываем в дескрипторе метод .write () для записи в него строк. В этом случае вместо использования параметра «rU» при вызове io.open () мы будем использовать «w» , чтобы указать, что мы хотим записать в файл.Будьте осторожны: когда вы открываете дескриптор файла для записи таким образом, он перезаписывает любое существующее содержимое файла. Если вы предпочитаете добавлять в файл, вместо этого можно использовать "a" .

В отличие от функции print () , метод .write () дескриптора файла не включает автоматически дополнительный символ новой строки "\ n" . Таким образом, если вы хотите записать несколько строк в дескриптор файла, вы должны добавить их самостоятельно. Вот пример, который печатает числа от 0 до 9 в файл, по одному в каждой строке.

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

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

Расчет среднего

Давайте применим на практике многие навыки, которые мы приобрели до сих пор, чтобы вычислить среднее значение E из выходных данных BLAST, которые отформатированы как простая текстовая таблица с вкладками, разделяющими столбцы.Вот как выглядит файл pz_blastx_yeast_top1.txt в формате less -S . Хотя читателю придется поверить нам на слово, одиннадцатый столбец этого файла содержит значений E , таких как 5e-14 , 2e-112 и 1e-18 .

При решении подобной проблемы обычно рекомендуется сначала написать на простом английском (или на другом языке, не являющемся языком программирования) стратегию , которую вы собираетесь использовать для решения проблемы.Стратегия здесь будет следующей: среднее значение набора чисел определяется как их сумма, деленная на их количество. Нам нужно сохранить как минимум две важные переменные: eval_sum и counter . После открытия файла с помощью io.open () мы можем перебрать строки и извлечь каждое значение E . (Для этого потребуется очистить строку с помощью .strip () , разбить ее на части с помощью .split ("\ t") и, наконец, преобразовать значение E в число с плавающей запятой вместо использования строки.) Для каждой строки, которую мы видим, мы можем добавить значение E , извлеченное к переменной eval_sum , и мы также добавим 1 к переменной counter . В конце концов, мы можем просто сообщить eval_sum / counter .

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

 импорт io
открытая ручка

counter = 0
sum_eval = 0.0

для каждой строки в fhandle
linestripped = line.strip ()
разбить список строк с помощью line_list = linestripped.split ("\ t")
eval как строка находится в line_list с индексом 10 (11-й столбец)
добавить float (eval) к sum_eval и сохранить в sum_eval
прибавьте 1 для подсчета и сохраните при подсчете
 
mean = sum_eval деленное на счетчик
print ("среднее значение" + среднее значение) 

Набросав псевдокод, мы можем написать реальный код нашей программы. При выполнении он надежно печатает Среднее значение: 1.37212611293e-08 .

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

Это может показаться изрядным объемом работы для вычисления простого среднего, но это следствие написания программного обеспечения «с нуля», и мы должны с чего-то начинать! Кроме того, польза от изучения этих методов окупится в долгосрочной перспективе, когда дело доходит до решения новых проблем.

Процесс программирования

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

Здесь стоит отметить еще одну вещь: программы, подобные вышеупомянутой, почти никогда не пишутся полностью сверху вниз, по крайней мере, без значительной отладки! Вы можете забыть, что в результате разделения строки получается список строк, что приводит к ошибке в строке типа eval_sum = eval_sum + eval_str , потому что eval_sum - это число с плавающей запятой, а eval_str - строка.После обнаружения и исправления этой ошибки вы можете обнаружить еще одну ошибку, если попытаетесь напечатать строку вроде print ("Mean is:" + mean) , потому что снова типы не совпадают и не могут быть объединены. После всего этого, возможно, вы обнаружите, что результирующее среднее значение неожиданно оказалось большим числом, например 131.18 , только чтобы узнать, что это произошло потому, что вы случайно использовали eval_str = line_list [11] , забывая, что индексы списка начинаются с 0 .

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

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

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

Упражнения

1. Напишите программу на Python для вычисления выборочного стандартного отклонения значений E в файле pz_blastx_yeast_top1.txt . Напоминаем, что стандартное отклонение выборки определяется как квадратный корень из суммы квадратов отличий от среднего, деленный на количество значений минус 1:

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

   Чтобы вычислить квадратный корень из числа с плавающей запятой, вам нужно будет импортировать модуль math , вызвав import math в верхней части программы. Тогда функция math.sqrt () вернет квадратный корень из числа с плавающей запятой; например, math.sqrt (3.0) вернет число с плавающей запятой 1.7320508 .

2. Если a_list - это список, то b_list = reversed (a_list) создает « listreverseiterator », позволяющий перебирать элементы с помощью цикла for в обратном порядке.Используя эту информацию, напишите программу с именем reverse_blast.py , которая считывает содержимое pz_blastx_yeast_top1.txt и записывает строки в обратном порядке в файл с именем pz_blastx_yeast_top1_reversed.txt .
3. A quine (в честь логика и философа В. В. Куайна) - это непустая программа, которая точно печатает собственный исходный код. Используйте модуль io и дескрипторы файлов, чтобы написать quine под названием quine.py .(Программам Quine технически запрещено открывать файлы. Можно ли написать программу, которая печатает собственный исходный код без использования модуля io ?)

Python 2.7 Учебное пособие

myfile = open ('alice.txt', 'r')

myfile.close ()
foo.py
 

myfile = open ('результаты.txt', 'ш')

myfile.close ()

myfile = open ('results.txt', 'а')

myfile.close ()
foo.py
 

>>> f = open ('mary-short.txt')
>>> marytxt = f.читать()
>>> f.close ()
>>> marytxt
'У Мэри был ягненок, \ nЕго шерсть была бела, как снег, \ nИ везде, где Мэри
пошел, \ nЯгненок обязательно должен был пойти. \ n '
>>> тип (marytxt)
<тип 'str'>
>>> len (marytxt)
110
>>> напечатать marytxt [0]
M
 

>>> f = open ('mary-short.txt')
>>> marylines = f.readlines ()
>>> f.close ()
>>> marylines
['У Марии был ягненок, \ n', 'Его шерсть была бела, как снег, \ n', 'И везде
что Мэри пошла, \ n ',' Ягненок обязательно должен был пойти. \ n ']
>>> тип (marylines)
<тип 'список'>
>>> len (marylines)
4
>>> напечатать marylines [0]
У Мэри был маленький ягненок,

 

f = open ('библия-kjv.txt')
для строки в f:
    если 'поразить' в строке:
        линия печати,

f.close ()
foo.py
 

>>> fout = open ('hello.txt', 'ш')
>>> fout.write ('Привет, мир! \ n')
>>> fout.write ('Меня зовут Гомер. \ n')
>>> фаут.напишите ("Какой у нас прекрасный день. \ n")
>>> fout.close ()
 

>>> tobuy = ['молоко \ n', 'масло \ n', 'кофейные зерна \ n', 'руккола \ n']
>>> fout = open ('grocerylist.txt', 'w')
>>> fout.writelines (купить)
>>> фаут.Закрыть()
 

>>> f = open ('mary-short.txt')
Отслеживание (последний вызов последний):
  Файл "", строка 1, в
IOError: [Errno 1] Нет такого файла или каталога: 'mary-short.txt'
 

>>> f = open ('mary-short.txt')
>>> marytxt = f.read ()
>>> marylines = f.readlines ()
>>> f.close ()
>>> len (marytxt)
110
>>> len (marylines)
0
 

>>> пи = 3.141592
>>> fout = open ('math.txt', 'ш')
>>> fout.write ("Число Пи")
>>> fout.write (пи)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в
TypeError: ожидается объект символьного буфера
>>> fout.write (str (pi))
>>>