Штирлиц — Сеть печатных салонов в Перми

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

Python 3 чтение из файла: Основы работы с файлами в Python

Содержание

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

Михаил Свинцов

автор курса «Full-stack веб-разработчик на Python»

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

Встроенные средства Python

Основа для работы с файлами — built-in функция open()

open(file, mode="rt")

Эта функция имеет два аргумента. Аргумент file принимает строку, в которой содержится путь к файлу. Второй аргумент, mode, позволяет указать режим, в котором необходимо работать с файлом. По умолчанию этот аргумент принимает значение «rt», с которым, и с некоторыми другими, можно ознакомиться в таблице ниже

Эти режимы могут быть скомбинированы. Например, «rb» открывает двоичный файл для чтения. Комбинируя «r+» или «w+» можно добиться открытия файла в режиме и чтения, и записи одновременно с одним отличием — первый режим вызовет исключение, если файла не существует, а работа во втором режиме в таком случае создаст его.

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

  • name — название файла;
  • mode — режим, в котором этот файл открыт;
  • closed — возвращает True, если файл был закрыт.

По завершении работы с файлом его необходимо закрыть при помощи метода close()

f = open("examp.le", "w")
//  работа с файлом
f.close()

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

with open("examp.le", "w") as f:
// работа с файлом

Главное отличие заключается в том, что python самостоятельно закрывает файл, и разработчику нет необходимости помнить об этом. И бонусом к этому не будут вызваны исключения при открытии файла (например, если файл не существует).

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

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

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

with open("examp.le", "r") as f:
    text = f.read()

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

with open("examp.le", "r") as f:
    part = f.read(16)

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

seek().

with open("examp.le", "r") as f: # 'Hello, world!'
    first_part = f.read(8)       # 'Hello, w'
    f.seek(4)
    second_part = f.read(8)      # 'o, world'

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

with open("examp.le", "r") as f:
    for line in f.readlines():
        print(line)

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

with open("examp.le", "r") as f:
    for line in f:
        print(line)

Запись в файл

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

Самый простой и логичный — использование функции write()

with open("examp.le", "w") as f:
    f.write(some_string_data)

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

для объектов или форматированные строки.

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

with open("examp.le", "w") as f:
    f.writelines(list_of_strings)

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

Существует еще один, менее известный, способ, но, возможно, самый удобный из представленных. И как бы не было странно, он заключается в использовании функции print(). Сначала это утверждение может показаться странным, потому что общеизвестно, что с помощью нее происходит вывод в консоль. И это правда. Но если передать в необязательный аргумент file объект типа io.TextIOWrapper, каким и является объект файла, с которым мы работаем, то поток вывода функции print() перенаправляется из консоли в файл.

with open("examp.le", "w") as f:
    print(some_data, file=f)

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

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

Чтение из файла построчно в Python на примерах readline, readlines и цикла for

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

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

readline(), readlines() и объект файла на примерах различных программ.

Пример 1: Чтение файла построчно функцией readline()

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

Как использовать функцию file.readline()

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

  1. Открываем файл в режиме чтения. При этом возвращается дескриптор файла.
  2. Создаём бесконечный цикл while.
    1. В каждой итерации считываем строку файла при помощи readline().
    2. Если строка не пустая, то выводим её и переходим к следующей. Вы можете проверить это, используя конструкцию if not. В противном случае файл больше не имеет строк и мы останавливаем цикл с помощью break.
  3. К моменту выхода из цикла мы считаем все строки файла в итерациях одну за другой.
  4. После этого мы закрываем файл, используя функцию
    close    .
# получим объект файла
file1 = open("sample.txt", "r")

while True:
    # считываем строку
    line = file1.readline()
    # прерываем цикл, если строка пустая
    if not line:
        break
    # выводим строку
    print(line.strip())

# закрываем файл
file1.close

Вывод:

Привет!
Добро пожаловать на PythonRu.
Удачи в обучении!

Пример 2: Чтение строк как список функцией readlines()

Функция readlines() возвращает все строки файла в виде списка. Мы можем пройтись по списку и получить доступ к каждой строке.

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

# получим объект файла
file1 = open("sample.txt", "r")

# считываем все строки
lines = file1.readlines()

# итерация по строкам
for line in lines:
    print(line.strip())

# закрываем файл
file1.close

 
 
Привет!
Добро пожаловать на PythonRu.
Удачи в обучении!

Пример 3: Считываем файл построчно из объекта File

В нашем первом примере, мы считываем каждую строку файла при помощи бесконечного цикла while и функции readline(). Но Вы можете использовать цикл for для файлового объекта, чтобы в каждой итерации цикла получать строку, пока не будет достигнут конец файла.

Ниже приводится программа, демонстрирующая применение оператора for-in, для того, чтобы перебрать строки файла.

Для демонстрации откроем файл с помощью with open. Это применимо и к предыдущим двум примерам.

# получим объект файла
with open("sample.txt", "r") as file1:
    # итерация по строкам
    for line in file1:
        print(line.strip())

Привет!
Добро пожаловать на PythonRu.
Удачи в обучении!

Выводы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Python 3-чтение текста из файла



Это упражнение 15 из Learn Python The Hard Way, но я использую Python 3 .

from sys import argv
script, filename = argv

txt = open(filename)
print ("Here's your file %r:") % filename
print txt.read()

print ("I'll also ask you to type it again:")
file_again = input()
txt_again = open(file_again)
print txt_again.read()

файл сохраняется как ex15.py, и когда я запускаю его из terminal, он читает ex15.txt правильно в первый раз, но когда я запрашиваю его во второй раз, я получаю ошибку

user@user:~/Desktop/python$ python ex15.py ex15.txt<br>
Here's your file 'ex15.txt':<br>
This is stuff I typed into a file.<br>
It is really cool stuff.<br>
Lots and lots of fun to have in here.<br>

I'll also ask you to type it again:<br>
ex15.txt <b>#now I type this in again, and I get a following error</b><br>
Traceback (most recent call last):<br>
  File "ex15.py", line 11, in <<module>module><br>
    file_again = input()<br>
  File "<<string\>string>", line 1, in <<module>module><br>
NameError: name 'ex15' is not defined

— Что случилось?

python python-3.x
Поделиться Источник JohnSmith     18 октября 2012 в 22:17

4 ответа

  • Python; чтение файла и поиск нужного текста

    Нужно создать функцию с двумя парами, именем файла для открытия и шаблоном. Шаблон будет строкой поиска. Например, функция откроет sentence.txt, который имеет что-то вроде The quick brown fox (возможно, это может быть более одной строки) Шаблон будет brown fox Поэтому, если он найден, как это…

  • Чтение списка из файла в python

    У меня есть файл, из которого в каждой строке содержится следующее: имя файла, длина списка, фактический список. Вот пример: a.txt 3 [4,2,9] b.txt 5 [1,6,5,2,8] c.txt 7 [1,2,3,4,5,6,7] и так далее. Мне удалось прочитать все до списка, но список читается как строки. Например, для первого из них…


7

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

  • Эти операторы print не имеют круглых скобок (которые требуются в Python 3, но не 2):

    print ("Here's your file %r:") % filename
print txt.read()

print txt_again.read()

  • Это вызов eval на input() , который был изменен в Python 3 :

    file_again = input()

Скорее всего, Python 2-это значение по умолчанию в вашей системе, но вы можете сделать так, чтобы ваш скрипт всегда использовал Python 3, добавив его в первую строку вашего скрипта (если вы запускаете его напрямую, например ./myscript.py ):

#!/usr/bin/env python3

Или запустить его явно с Python 3:

python3 myscript.py

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

txt = open(filename)
# do stuff needing text
txt.close()

Или используйте оператор with и обработайте его, когда блок закончится:

with open(filename) as txt:
    # do stuff needing txt
# txt is closed here

Поделиться Brendan Long     18 октября 2012 в 22:27


5

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

print txt.read() это не работает в py3k, поэтому убедитесь, что вы действительно используете py3k.

вам нужно использовать raw_input() вместо input() , потому что вы находитесь на py 2.x .

пример py 2.x:

>>> x=raw_input()
foo
>>> x=input()   # doesn't works as it tries to find the variable bar
bar                    
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'bar' is not defined

пример py 3.x:

>>> x=input()
foo
>>> x       # works fine
'foo'

Поделиться Ashwini Chaudhary     18 октября 2012 в 22:21


3

Похоже, вы не используете python 3.0.. чтобы проверить это, просто введите в окно terminal:

python

и посмотрите на информационные строки, которые появляются при запуске интерператора.

Python 2.7.3 (default, Apr 10 2012, 23:31:26) [MSC v.1500 32 bit (Intel
32
Type "help", "copyright", "credits" or "license" for more information.

Это должно быть что-то вроде этого,
для python 2.7.3 , а для python 3.X.X вместо этого будет сказано python 3.X.X .

Если вы используете python 2.X, Ashwini Chaudhary имеет правильный ответ.

Поделиться Serdalis     18 октября 2012 в 22:25

  • Python чтение файла перемотка назад

    Чтение файла с помощью Python. Формат файла выглядит следующим образом: [22/Oct/2013] GET KEYWORD apple/banana/tomato ID=23q539283492u39 ERROR:2 ERROR:3 parameters={} … Меня интересуют только все ERROR:3, поэтому, как только будет замечен ERROR:3, необходимо извлечь первую строку (время и…

  • Чтение файла .pcap из STDIN в Python Scapy

    есть ли способ прочитать .pcap из stdin в Python Scapy (используя rdpcap)? Каждый раз, когда я что-то пробую, я получаю ошибку (не могу прочитать файл). Использование выглядит следующим образом: python main.py < test_linux.pcap Я уже реализовал чтение файла с помощью параметров, но мне также…


0

Попробуйте этот код для py3k:

txt = open(filename, 'r')
print('Here\'s your file %r: ' % filename)
print(txt.read())
txt.close()

print('I\'ll also ask you to type it again: ')
file_again = input()
txt_again = open(file_again, 'r')
print(txt_again.read())
txt_again.close()

Поделиться nickanor     19 октября 2012 в 19:02

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


Чтение байтов из файла без указания кодировки в Python 3

В Python 2 Следующее с радостью загрузит первые два байта из двоичного файла: with open(file_name) as f: b = f.read(2) Однако в Python 3 то же самое может привести, например, к: UnicodeDecodeError:…


Python 3-копирование блока текста из файла ASCII

Я хочу скопировать блок текста из файла ASCII. Например, из строки: *ELEMENT, TYPE=S3, ELSET=DAM до самой линии: *ELEMENT, TYPE=S4, ELSET=WALL , а затем запишите его в новый файл ASCII. Не могли бы…


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

Возможный дубликат : Получить последние n строк файла с Python, аналогично хвосту Чтение файла в обратном порядке с помощью python У меня есть файл размером около 15 ГБ, это файл журнала, из…


Python; чтение файла и поиск нужного текста

Нужно создать функцию с двумя парами, именем файла для открытия и шаблоном. Шаблон будет строкой поиска. Например, функция откроет sentence.txt, который имеет что-то вроде The quick brown fox…


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

У меня есть файл, из которого в каждой строке содержится следующее: имя файла, длина списка, фактический список. Вот пример: a.txt 3 [4,2,9] b.txt 5 [1,6,5,2,8] c.txt 7 [1,2,3,4,5,6,7] и так далее….


Python чтение файла перемотка назад

Чтение файла с помощью Python. Формат файла выглядит следующим образом: [22/Oct/2013] GET KEYWORD apple/banana/tomato ID=23q539283492u39 ERROR:2 ERROR:3 parameters={} … Меня интересуют только все…


Чтение файла .pcap из STDIN в Python Scapy

есть ли способ прочитать .pcap из stdin в Python Scapy (используя rdpcap)? Каждый раз, когда я что-то пробую, я получаю ошибку (не могу прочитать файл). Использование выглядит следующим образом:…


Чтение двоичного файла и текста из одного файла в Python

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


Создание объекта Python из строки в Python 3

Это не дубликат создания объекта функции из строки , потому что это решение Python 2 с exec , а не как function() Попытка реализовать это решение в Python 3 приводит к следующему: d = {} exec(def…


Извлечение текста из файла .PST

Я пытаюсь извлечь содержимое (как string/text) файла .pst . Я пробовал разные ответы, но не нашел никакого подходящего решения. Outlook PST-анализ файла в Python Чтение файлов PST из win32 или pypff…

Запись в файл Python. Перезапись файла Python

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

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

Работа с текстовым файлом в Python начинается с момента вызова функции open. Она принимает в качестве атрибутов путь к объекту на ПК и режим обработки. Вы можете указать абсолютный путь (это адрес размещения на жёстком диске) или относительный (речь идёт о координатах относительно папки проекта).

Что касается режима обработки файла, то при его выборе учитывайте его назначение («r» — для чтения, «w» — для записи). Таблица ниже позволит вам ознакомиться с режимами доступа к файлу в Python:

А вот пример простейшего взаимодействия с текстовым документом:

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

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

Метод close закрывает файл, а это необходимо сделать, выполнив нужные вам действия с переменной file (иначе потеряете информацию). Впрочем, можно обойтись и без close, используя связку операторов with as (переменная, которая ссылается на файл, должна быть прописана после конструкции):

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

Метод write() для записи в файл в Python

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

Запись в файл построчно выполняется посредством записи нужной вам строки с последующей записью \n— символа перевода строки.

Давайте ещё раз посмотрим на запись в файл с помощью метода write(). Синтаксис:

Пример использования:
    my_file = open("otus.txt", "w")
my_file.write("Люблю Python!\nЭто крутой язык!")
my_file.close()

Код, представленный выше, создаст файл otus.txt , записав в него указанную строку.
Давайте теперь выполним запись списка поэлементно, где каждый элемент списка будет записан в новой строке:
lines = ["one", "two", "three"]
with open(r"C:\otus.txt", "w") as file:
    for  line in lines:
        file.write(line + '\n')

Этот код позволит создать небольшой массив lines, содержащий три строковых элемента: «one», «two» и «three». Благодаря функции open и связке операторов with as произойдёт открытие текстового файла otus.txt в корневом каталоге жёсткого диска C. Далее произойдёт запись всех элементов списка с помощью write. Символ \n обеспечит, чтобы каждая запись была выполнена с новой строки.
Python | Текстовые файлы
Текстовые файлы
Последнее обновление: 21.06.2017
Запись в текстовый файл
Чтобы открыть текстовый файл на запись, необходимо применить режим w (перезапись) или a (дозапись). Затем для записи применяется метод write(str), 
в который передается записываемая строка. Стоит отметить, что записывается именно строка, поэтому, если нужно записать числа, данные других типов, то их 
предварительно нужно конвертировать в строку.
Запишем некоторую информацию в файл «hello.txt»:

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

Если мы откроем папку, в которой находится текущий скрипт Python, то увидем там файл hello.txt. Этот файл можно открыть в любом текстовом редакторе и при желании изменить.
Теперь дозапишем в этот файл еще одну строку:

with open("hello.txt", "a") as file:
    file.write("\ngood bye, world")

Дозапись выглядит как добавление строку к последнему символу в файле, поэтому, если необходимо сделать запись с новой строки, то можно использовать эскейп-последовательность «\n». 
В итоге файл hello.txt будет иметь следующее содержимое:

hello world
good bye, world

Еще один способ записи в файл представляет стандартный метод print(), который применяется для вывода данных на консоль:

with open("hello.txt", "a") as hello_file:
    print("Hello, world", file=hello_file)

Для вывода данных в файл в метод print в качестве второго параметра передается название файла через параметр file. А первый параметр представляет записываемую 
в файл строку.
Чтение файла
Для чтения файла он открывается с режимом r (Read), и затем мы можем считать его содержимое различными методами:
  • readline(): считывает одну строку из файла
    • 
  • read(): считывает все содержимое файла в одну строку
    • 
  • readlines(): считывает все строки файла в список
    • 
Например, считаем выше записанный файл построчно:

with open("hello.txt", "r") as file:
    for line in file:
        print(line, end="")

Несмотря на то, что мы явно не применяем метод readline() для чтения каждой строки, но в при переборе файла этот метод автоматически вызывается 
для получения каждой новой строки. Поэтому в цикле вручную нет смысла вызывать метод readline. И поскольку строки разделяются символом перевода строки «\n», то чтобы исключить излишнего переноса на другую строку в функцию 
print передается значение end="".
Теперь явным образом вызовем метод readline() для чтения отдельных строк:

with open("hello.txt", "r") as file:
    str1 = file.readline()
    print(str1, end="")
    str2 = file.readline()
    print(str2)

Консольный вывод:

hello world
good bye, world

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

with open("hello.txt", "r") as file:
    line = file.readline()
    while line:
        print(line, end="")
        line = file.readline()

Если файл небольшой, то его можно разом считать с помощью метода read():

with open("hello.txt", "r") as file:
    content = file.read()
    print(content)

И также применим метод readlines() для считывания всего файла в список строк:

with open("hello.txt", "r") as file:
    contents = file.readlines()
    str1 = contents[0]
    str2 = contents[1]
    print(str1, end="")
    print(str2)

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

filename = "hello.txt"
with open(filename, encoding="utf8") as file:
    text = file.read()

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

# имя файла
FILENAME = "messages.txt"
# определяем пустой список
messages = list()

for i in range(4):
    message = input("Введите строку " + str(i+1) + ": ")
    messages.append(message + "\n")

# запись списка в файл
with open(FILENAME, "a") as file:
    for message in messages:
        file.write(message)

# считываем сообщения из файла
print("Считанные сообщения")
with open(FILENAME, "r") as file:
    for message in file:
        print(message, end="")

Пример работы программы:

Введите строку 1: hello
Введите строку 2: world peace
Введите строку 3: great job
Введите строку 4: Python
Считанные сообщения
hello
world peace
great job
Python

Чтение файлов — Документация Python для сетевых инженеров 3.0
В Python есть несколько методов чтения файла:
  • read — считывает содержимое файла в строку
  • readline — считывает файл построчно
  • readlines — считывает строки файла и создает список из строк
Посмотрим как считывать содержимое файлов, на примере файла r1.txt:
!
service timestamps debug datetime msec localtime show-timezone year
service timestamps log datetime msec localtime show-timezone year
service password-encryption
service sequence-numbers
!
no ip domain lookup
!
ip ssh version 2
!

read
Метод read — считывает весь файл в одну строку.
Пример использования метода read:
In [1]: f = open('r1.txt')

In [2]: f.read()
Out[2]: '!\nservice timestamps debug datetime msec localtime show-timezone year\nservice timestamps log datetime msec localtime show-timezone year\nservice password-encryption\nservice sequence-numbers\n!\nno ip domain lookup\n!\nip ssh version 2\n!\n'

In [3]: f.read()
Out[3]: ''

При повторном чтении файла в 3 строке, отображается пустая строка. Так
происходит из-за того, что при вызове метода read, считывается
весь файл. И после того, как файл был считан, курсор остается в конце
файла. Управлять положением курсора можно с помощью метода seek.
readline
Построчно файл можно считать с помощью метода readline:
In [4]: f = open('r1.txt')

In [5]: f.readline()
Out[5]: '!\n'

In [6]: f.readline()
Out[6]: 'service timestamps debug datetime msec localtime show-timezone year\n'

Но чаще всего проще пройтись по объекту file в цикле, не используя
методы read...:
In [7]: f = open('r1.txt')

In [8]: for line in f:
   ...:     print(line)
   ...:
!

service timestamps debug datetime msec localtime show-timezone year

service timestamps log datetime msec localtime show-timezone year

service password-encryption

service sequence-numbers

!

no ip domain lookup

!

ip ssh version 2

!

readlines
Еще один полезный метод — readlines. Он считывает строки файла в
список:
In [9]: f = open('r1.txt')

In [10]: f.readlines()
Out[10]:
['!\n',
 'service timestamps debug datetime msec localtime show-timezone year\n',
 'service timestamps log datetime msec localtime show-timezone year\n',
 'service password-encryption\n',
 'service sequence-numbers\n',
 '!\n',
 'no ip domain lookup\n',
 '!\n',
 'ip ssh version 2\n',
 '!\n']

Если нужно получить строки файла, но без перевода строки в конце, можно
воспользоваться методом split и как разделитель, указать символ \n:
In [11]: f = open('r1.txt')

In [12]: f.read().split('\n')
Out[12]:
['!',
 'service timestamps debug datetime msec localtime show-timezone year',
 'service timestamps log datetime msec localtime show-timezone year',
 'service password-encryption',
 'service sequence-numbers',
 '!',
 'no ip domain lookup',
 '!',
 'ip ssh version 2',
 '!',
 '']

Обратите внимание, что последний элемент списка — пустая строка.
Если перед выполнением split, воспользоваться методом rstrip, список будет без пустой строки в конце:
In [13]: f = open('r1.txt')

In [14]: f.read().rstrip().split('\n')
Out[14]:
['!',
 'service timestamps debug datetime msec localtime show-timezone year',
 'service timestamps log datetime msec localtime show-timezone year',
 'service password-encryption',
 'service sequence-numbers',
 '!',
 'no ip domain lookup',
 '!',
 'ip ssh version 2',
 '!']

seek
До сих пор, файл каждый раз приходилось открывать заново, чтобы снова
его считать. Так происходит из-за того, что после методов чтения, курсор
находится в конце файла. И повторное чтение возвращает пустую строку.
Чтобы ещё раз считать информацию из файла, нужно воспользоваться методом seek, который перемещает курсор в необходимое положение.
Пример открытия файла и считывания содержимого:
In [15]: f = open('r1.txt')

In [16]: print(f.read())
!
service timestamps debug datetime msec localtime show-timezone year
service timestamps log datetime msec localtime show-timezone year
service password-encryption
service sequence-numbers
!
no ip domain lookup
!
ip ssh version 2
!

Если вызывать ещё раз метод read, возвращается пустая строка:
Но с помощью метода seek можно перейти в начало файла (0 означает
начало файла):
После того как с помощью seek курсор был переведен в начало
файла, можно опять считывать содержимое:
In [19]: print(f.read())
!
service timestamps debug datetime msec localtime show-timezone year
service timestamps log datetime msec localtime show-timezone year
service password-encryption
service sequence-numbers
!
no ip domain lookup
!
ip ssh version 2
!

 Как читать и записывать файлы в Python 3 
 Введение 
 Python — отличный инструмент для обработки данных. Вполне вероятно, что любая программа, которую вы пишете, будет включать чтение, запись или манипулирование данными. По этой причине особенно полезно знать, как работать с разными форматами файлов, в которых хранятся разные типы данных.
 Например, рассмотрим программу Python, которая проверяет список пользователей на предмет контроля доступа. Ваш список пользователей, скорее всего, будет сохранен в текстовом файле.Возможно, вы не работаете с текстом, а вместо этого имеете программу, которая выполняет финансовый анализ. Чтобы выполнить некоторую обработку чисел, вам, вероятно, придется ввести эти числа из сохраненной электронной таблицы. Независимо от вашего приложения, почти гарантировано, что будет задействован ввод или вывод данных.
 В этом руководстве кратко описаны некоторые типы форматов, которые может обрабатывать Python. После краткого введения в форматы файлов мы рассмотрим, как открывать, читать и записывать текстовый файл в Python 3.
 Когда вы закончите изучение этого руководства, вы сможете работать с любым текстовым файлом в Python.
 Предварительные требования 
 Для этого руководства у вас должен быть установлен Python 3, а также настроена локальная среда программирования на вашем компьютере. Если это не так, вы можете выполнить настройку, следуя соответствующему руководству по установке и настройке для вашей операционной системы:
 Фон 
 Python очень удобен и может с относительной легкостью обрабатывать ряд различных форматов файлов, включая, помимо прочего, следующие:
  Тип файла   Описание 
 текст В текстовом файле хранятся данные, представляющие только символы (или строки), и исключаются любые структурированные метаданные.
 CSV В файле значений, разделенных запятыми, используются запятые (или другие разделители) для структурирования хранимых данных, что позволяет сохранять данные в табличном формате.
 HTML Файл языка разметки гипертекста хранит структурированные данные и обычно используется на большинстве веб-сайтов.
 JSON JavaScript Object Notation — простой и эффективный формат, что делает его одним из наиболее часто используемых форматов для хранения и передачи данных.
 В этом руководстве основное внимание уделяется файловому формату  txt .
 Шаг 1. Создание текстового файла 
 Прежде чем мы сможем начать работать с Python, нам нужно убедиться, что у нас есть файл, с которым можно работать. Для этого мы откроем текстовый редактор и создадим новый текстовый файл, назовем его  days.txt .
 В новом файле введите несколько строк текста. В этом примере давайте перечислим дни недели:
.
 days.txt
  Понедельник
вторник
среда
четверг
Пятница
Суббота
Воскресенье
  
 Затем сохраните файл и убедитесь, что знаете, куда вы его поместили.В нашем примере наш пользователь  sammy  сохранил файл здесь:  /users/sammy/days.txt . Это будет очень важно на следующих этапах, когда мы откроем файл в Python.
 Теперь, когда у нас есть текстовый файл для обработки, мы можем начать наш код!
 Шаг 2 — Открытие файла 
 Прежде чем мы сможем написать нашу программу, мы должны создать программный файл Python, поэтому создайте файл  files.py  в текстовом редакторе. Чтобы упростить задачу, сохраните его в том же каталоге, что и наши дни .txt  файл:  / users / sammy / .
 Чтобы открыть файл в Python, нам сначала нужно каким-то образом связать файл на диске с переменной в Python. Этот процесс называется , открывая  файл. Мы начинаем с того, что сообщаем Python, где находится файл. Расположение вашего файла часто обозначается как путь к файлу  . Чтобы Python мог открыть ваш файл, ему требуется путь. Путь к нашему файлу  days.txt :  /users/sammy/days.txt . В Python мы создадим строковую переменную для хранения этой информации.В нашем сценарии  files.py  мы создадим переменную  path  и установим для нее путь days.txt.
 files.py
  путь = '/users/sammy/days.txt'
  
 Затем мы воспользуемся функцией Python  open () , чтобы открыть наш файл  days.txt . Функция  open ()  требует в качестве первого аргумента путь к файлу. Функция также позволяет использовать многие другие параметры. Однако наиболее важным является необязательный параметр  mode .Mode — это необязательная строка, определяющая режим, в котором открывается файл. Выбранный вами режим будет зависеть от того, что вы хотите делать с файлом. Вот некоторые из наших вариантов режима:
  •   'r' : использовать для чтения
  •   'w' : использовать для записи
  •   'x' : используйте для создания и записи в новый файл
  •   'a' : использовать для добавления в файл
  •   'r +' : использовать для чтения и записи в один и тот же файл
 В этом примере мы хотим только читать из файла, поэтому мы будем использовать режим  'r' .Мы воспользуемся функцией  open () , чтобы открыть файл  days.txt  и присвоить его переменной  days_file .
 files.py
  days_file = open (путь, 'r')
  
 После того, как мы открыли файл, мы можем читать из него, что мы и сделаем на следующем шаге.
 Шаг 3 — Чтение файла 
 Поскольку наш файл был открыт, теперь мы можем управлять им (т.е. читать из него) через переменную, которую мы ему присвоили. Python предоставляет три связанных операции для чтения информации из файла.Мы покажем, как использовать все три операции в качестве примеров, которые вы можете попробовать, чтобы понять, как они работают.
 Первая операция   .read ()  возвращает все содержимое файла в виде одной строки.
  days_file.read ()
  
  
 Выход 
 'Понедельник \ n Вторник \ n Среда \ n Четверг \ n Пятница \ n Суббота \ nВоскресенье \ n'
  
 Вторая операция  <файл> .readline ()  возвращает следующую строку файла, возвращая текст до следующего символа новой строки включительно.Проще говоря, эта операция будет читать файл построчно.
  days_file.readline ()
  
  
 Выход 
 'Понедельник \ n'
  
 Следовательно, как только вы прочитаете строку с операцией чтения, она перейдет к следующей строке. Поэтому, если бы вы снова вызывали эту операцию, она вернула бы следующую строку в файле, как показано.
  days_file.readline ()
  
  
 Выход 
 'Вторник \ n'
  
 Последняя операция,  <файл>.readlines ()  возвращает список строк в файле, где каждый элемент списка представляет одну строку.
  days_file.readlines ()
  
  
 Вывод 
 ['понедельник \ n', 'вторник \ n', 'среда \ n', 'четверг \ n', 'пятница \ n', 'суббота \ n', 'воскресенье \ n']
  
 Следует иметь в виду, когда вы читаете из файлов, поскольку после того, как файл был прочитан с помощью одной из операций чтения, он не может быть прочитан снова. Например, если вы сначала запустите  days_file.read () , за которым следует  days_file.readlines () , вторая операция вернет пустую строку. Следовательно, в любое время, когда вы захотите прочитать из файла, вам придется сначала открыть новую файловую переменную. Теперь, когда мы прочитали из файла, давайте узнаем, как записать в новый файл.
 Шаг 4 — Запись файла 
 На этом этапе мы собираемся написать новый файл, который будет включать заголовок «Дни недели», за которым следуют дни недели. Во-первых, давайте создадим нашу переменную  title .
 files.py
  title = 'Дни недели \ n'
  
 Нам также нужно сохранить дни недели в строковой переменной, которую мы назовем  days . Чтобы упростить отслеживание, мы включаем код из описанных выше шагов. Мы открываем файл в режиме чтения, читаем файл и сохраняем возвращенный результат операции чтения в нашей новой переменной  дней .
 files.py
  путь = '/users/sammy/days.txt'
days_file = open (путь, 'r')
days = days_file.читать()
  
 Теперь, когда у нас есть переменные для заголовка и дней недели, мы можем начать запись в наш новый файл. Во-первых, нам нужно указать расположение файла. Опять же, мы будем использовать каталог  / users / sammy / . Нам нужно будет указать новый файл, который мы хотим создать. Итак, наш путь на самом деле будет  /users/sammy/new_days.txt . Мы предоставляем информацию о нашем местоположении в переменной  new_path . Затем мы открываем наш новый файл в режиме записи, используя функцию  open ()  с указанным режимом  'w' .
 files.py
  new_path = '/users/sammy/new_days.txt'
new_days = open (новый_путь, 'w')
  
 Важно отметить, что если new_days.txt уже существовал до открытия файла, его старое содержимое было бы уничтожено, поэтому будьте осторожны при использовании режима  'w' .
 Как только наш новый файл открыт, мы можем поместить данные в файл, используя операцию записи,  <файл> .write () . Операция записи принимает единственный параметр, который должен быть строкой, и записывает эту строку в файл.Если вы хотите начать новую строку в файле, вы должны явно указать символ новой строки. Сначала мы записываем заголовок файла, а затем дни недели. Давайте также добавим некоторые печатные заявления о том, что мы пишем, что часто является хорошей практикой для отслеживания прогресса ваших скриптов.
 files.py
  new_days.write (заголовок)
печать (заголовок)

new_days.write (дни)
печать (дни)
  
 Наконец, когда мы заканчиваем работу с файлом, мы должны обязательно закрыть его.Мы покажем это на нашем последнем этапе.
 Шаг 5 — Закрытие файла 
 Закрытие файла гарантирует, что соединение между файлом на диске и файловой переменной завершено. Закрытие файлов также гарантирует, что другие программы смогут получить к ним доступ, и сохранит ваши данные в безопасности. Поэтому всегда закрывайте свои файлы. Теперь закроем все наши файлы с помощью функции   .close () .
 files.py
  days_file.close ()
new_days.close ()
  
 Мы закончили обработку файлов в Python и можем перейти к просмотру нашего кода.
 Шаг 6 — Проверка нашего кода 
 Прежде чем мы запустим наш код, давайте убедимся, что все в порядке. Конечный продукт должен выглядеть примерно так:
 files.py
  путь = '/users/sammy/days.txt'
days_file = open (путь, 'r')
days = days_file.read ()


new_path = '/users/sammy/new_days.txt'
new_days = open (новый_путь, 'w')

title = 'Дни недели \ n'
new_days.write (заголовок)
печать (заголовок)

new_days.write (дни)
печать (дни)

days_file.close ()
new_days.close ()
  
 После сохранения кода откройте терминал и запустите сценарий Python, например:
  
 Наш результат должен выглядеть так:
  
 Вывод 
 дней недели

понедельник
вторник
среда
четверг
Пятница
Суббота
Воскресенье
  
 Теперь давайте дважды проверим, что наш код полностью работает, открыв новый файл ( new_days.txt ). Если все прошло хорошо, когда мы откроем наш новый файл, он должен выглядеть так:
 new_days.txt
  Дни недели
понедельник
вторник
среда
четверг
Пятница
Суббота
Воскресенье
  
 Ваш файл будет выглядеть так же или похожим образом — вы успешно прошли это обучение!
 Заключение 
 В этом руководстве мы рассмотрели, как обрабатывать простые текстовые файлы и манипулировать ими в Python 3. Теперь вы можете открывать, читать, записывать и закрывать файлы в Python, а также продолжать работать со своими собственными данными в Python.
 Чтение и запись файлов на Python (Руководство) — Real Python 
 
 Персонаж Значение
  'r'  Открыто для чтения (по умолчанию)
  'ширина'  Открыть для записи, сначала обрезать (перезаписать) файл
  'rb'  или  'wb'  Открыть в двоичном режиме (чтение / запись с использованием байтовых данных)