Питон запись в файл: Файлы. Работа с файлами. | Python 3 для начинающих и чайников

Содержание

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

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

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

f = open('text.txt', 'r')

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

Режим Обозначение
‘r’ открытие на чтение (является значением по умолчанию).
‘w’ открытие на запись, содержимое файла удаляется, если файла не существует, создается новый.
‘x’ открытие на запись, если файла не существует, иначе исключение.
‘a’ открытие на дозапись, информация добавляется в конец файла.
‘b’ открытие в двоичном режиме.
‘t’ открытие в текстовом режиме (является значением по умолчанию).
‘+’ открытие на чтение и запись

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

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

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

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

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

>>> f = open('text.txt')
>>> f.read(1)
'H'
>>> f.read()
'ello world!\nThe end.\n\n'

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

>>> f = open('text.txt')
>>> for line in f:
...     line
...
'Hello world!\n'
'\n'
'The end.\n'
'\n'

Запись в файл

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

>>> l = [str(i)+str(i-1) for i in range(20)]
>>> l
['0-1', '10', '21', '32', '43', '54', '65', '76', '87', '98', '109', '1110', '1211', '1312', '1413', '1514', '1615', '1716', '1817', '1918']

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

>>> f = open('text.txt', 'w')

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

>>> for index in l:
...     f.write(index + '\n')
...
4
3
3
3
3

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

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

>>> f.close()

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

>>> f = open('text.txt', 'r')
>>> l = [line.strip() for line in f]
>>> l
['0-1', '10', '21', '32', '43', '54', '65', '76', '87', '98', '109', '1110', '1211', '1312', '1413', '1514', '1615', '1716', '1817', '1918']
>>> f.close()

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

Запись в файл 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

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

автор курса «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

Файл — это просто последовательность байтов, среди которых встречаются переносы строк. Т.е. если вы работаете с файлом:

строка 1
строчка 2
строка 3

…то на самом деле на диске лежит последовательность байтов:

строка 1␊строчка 2␊строка 3

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

строка 1␊XXXXXXXXXXXтрока 3

тогда, просматривая файл по строкам, вы увидите:

строка 1
XXXXXXXXXXXтрока 3

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


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

  1. читаем «строка 1», пропускаем:

              ↓ позиция для чтения
     строка 1␊строчка 2␊строка 3
     ↑ позиция для записи
    
  2. читаем «строчка 2»:

                        ↓ позиция для чтения
     строка 1␊строчка 2␊строка 3
     ↑ позиция для записи
    
  3. Записываем «строчка 2» на новое место:

                        ↓ позиция для чтения
     строчка 2␊трочка 2␊строка 3
               ↑ позиция для записи
    
  4. Аналогично, читаем «строка 3» и пишем ее на новое место:

                                ↓ позиция для чтения
     строчка 2␊строка 3␊строка 3
                        ↑ позиция для записи
    
  5. Обрезаем ненужное место в конце файла:

     строчка 2␊строка 3␊
    

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


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

python — Записать результат работы функции в файл

Можно в самом начале переопределить функцию print

old_print = print  # Запоминаем старую функцию print

def print(*args, **kwargs):  # Переопределяем
    if "file" not in kwargs:  # Если не передали параметр file
        with open("filename", "a") as fp:  # Будем записывать в файл filename
            old_print(*args, **kwargs, file=fp)
    else:
        old_print(*args, **kwargs)  # Иначе будем записывать в file, который передали

Но это очень плохая практика. Если кто-то будет смотреть Ваш код (возможно даже Вы сами через некоторое время), то Вам за это «спасибо» не скажут.


Другой способ: можно просто перенаправить stdout в файл. Для этого можно просто запустить скрипт так:

python script.py > filename

Тем самым всё будет печататься не в консоль, а в файл filename.


UPD (уже неактуально, но пусть будет)

Если Вы хотите выполнить только одну функцию из скрипта, то придётся в самом скрипте подключать модуль sys (встроенный) и смотреть параметры, переданные скрипту из командой строки. Например:

import sys


def func1(*args):
    print(args)  # Функционал функции


def func2(*args):
    print(args)  # Функционал функции

# ...

def run_all_funcs():  # запускает все функции
    func1()
    func2()
    # ...


if __name__ == "__main__":
    if len(sys.argv) == 2:  # Проверяем кол-во аргументов,
                            # переданных скрипту из командой строки
        if sys.argv[1] == "func1":
            func1()
        if sys.argv[1] == "func2":
            func2()
        # ...
    else:  # Если аргументов не передали, то запускаем все функции
        run_all_funcs()

И запуск тогда будет такой:

python script.py func2 > filename

Надеюсь, суть ясна.


UUPD

Сразу не подумал, можно намного проще. Если в файле script.py есть функция func(a, b), то только её можно вызвать так:

python -c "from script import *; func(1, 2)" > filename

Обратите внимание, что мы импортируем всё из файла script.py, но расширение .py не указываем.

Запись файлов — Документация Python для сетевых инженеров 3.0

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

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

При этом оба режима создают файл, если он не существует.

Для записи в файл используются такие методы:

  • write() — записать в файл одну строку
  • writelines() — позволяет передавать в качестве аргумента список строк

write()

Метод write ожидает строку, для записи.

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

In [1]: cfg_lines = ['!',
   ...:  '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',
   ...:  '!']

Открытие файла r2.txt в режиме для записи:

In [2]: f = open('r2.txt', 'w')

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

In [3]: cfg_lines_as_string = '\n'.join(cfg_lines)

In [4]: cfg_lines_as_string
Out[4]: '!\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!'

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

In [5]: f.write(cfg_lines_as_string)

Аналогично можно добавить строку вручную:

In [6]: f.write('\nhostname r2')

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

Так как ipython поддерживает команду cat, можно легко посмотреть
содержимое файла:

In [8]: cat r2.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
!
hostname r2

writelines()

Метод writelines() ожидает список строк, как аргумент.

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

In [1]: cfg_lines = ['!',
   ...:  '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',
   ...:  '!']

In [9]: f = open('r2.txt', 'w')

In [10]: f.writelines(cfg_lines)

In [11]: f.close()

In [12]: cat r2.txt
!service timestamps debug datetime msec localtime show-timezone yearservice timestamps log datetime msec localtime show-timezone yearservice password-encryptionservice sequence-numbers!no ip domain lookup!ip ssh version 2!

В результате все строки из списка записались в одну строку файла, так
как в конце строк не было символа \n.

Добавить перевод строки можно по-разному.
Например, можно просто обработать список в цикле:

In [13]: cfg_lines2 = []

In [14]: for line in cfg_lines:
   ....:     cfg_lines2.append( line + '\n' )
   ....:

In [15]: cfg_lines2
Out[15]:
['!\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',

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

In [18]: f = open('r2.txt', 'w')

In [19]: f.writelines(cfg_lines2)

In [20]: f.close()

In [21]: cat r2.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
!

Изучаем Python: работа с файлами

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

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

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

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

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

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

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

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

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

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

Открытие файла Python- возможные режимы
Режим Описание
‘r’ Открытие файла для чтения. Режим используется по умолчанию.
‘w’ Открытие файла для записи. Режим создаёт новый файл, если он не существует, или стирает содержимое существующего.
‘x’ Открытие файла для записи. Если файл существует, операция заканчивается неудачей (исключением).
‘a’ Открытие файла для добавления данных в конец файла без очистки его содержимого. Этот режим создаёт новый файл, если он не существует.
‘t’ Открытие файла в текстовом формате. Этот режим используется по умолчанию.
‘b’ Открытие файла в бинарном формате.
‘+’ Открытие файла для обновления (чтения и записи).
f = open("test.txt")      # эквивалент 'r' или 'rt'
f = open("test.txt",'w')  # запись в текстовом режиме
f = open("img.bmp",'r+b') # чтение и запись в бинарном формате

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

>>> f.readline()
''

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

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

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

Python работа с файлами — методы
Метод Описание
close() Закрытие файла. Не делает ничего, если файл закрыт.
detach() Отделяет бинарный буфер от TextIOBase и возвращает его.
fileno() Возвращает целочисленный дескриптор файла.
flush() Вызывает сброс данных (запись на диск) из буфера записи файлового потока.
isatty() Возвращает значение True, если файловый поток интерактивный.
read(n) Читает максимум n символов из файла. Читает до конца файла, если значение отрицательное или None.
readable() Возвращает значение True, если из файлового потока можно осуществить чтение.
readline(n=-1) Читает и возвращает одну строку из файла. Читает максимум n байт, если указано соответствующее значение.
readlines(n=-1) Читает и возвращает список строк из файла. Читает максимум n байт/символов, если указано соответствующее значение.
seek(offset,from=SEEK_SET) Изменяет позицию курсора.
seekable() Возвращает значение True, если файловый поток поддерживает случайный доступ.
tell() Возвращает текущую позицию курсора в файле.
truncate(size=None) Изменяет размер файлового потока до size байт. Если значение size не указано, размер изменяется до текущего положения курсора.
writable() Возвращает значение True, если в файловый поток может производиться запись.
write(s) Записывает строки s в файл и возвращает количество записанных символов.
writelines(lines) Записывает список строк lines в файл.

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

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

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

  • Текстовые файлы: В файлах этого типа каждая строка текста заканчивается специальным символом EOL (конец строки), который по умолчанию является символом новой строки (‘\ n’) в Python.
  • Двоичные файлы: В файлах этого типа отсутствует терминатор для строки, и данные сохраняются после их преобразования в понятный для машины двоичный язык.

Примечание: Чтобы узнать больше об обработке файлов, щелкните здесь.

Оглавление

Режим доступа

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

  1. Только запись («w»): Откройте файл для записи.Для существующего файла данные усекаются и перезаписываются. Ручка находится в начале файла. Создает файл, если файл не существует.
  2. Запись и чтение («w +»): Откройте файл для чтения и записи. Для существующего файла данные усекаются и перезаписываются. Ручка находится в начале файла.
  3. Только добавление (‘a’): Откройте файл для записи. Если файл не существует, он создается. Ручка находится в конце файла.Записываемые данные будут вставлены в конце после существующих данных.

Примечание: Чтобы узнать больше о режиме доступа, щелкните здесь.

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

Это делается с помощью функции open () . Для этой функции импорт модуля не требуется.

Синтаксис:

File_object = open (r "Имя_файла", "Режим_доступа")
 

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

Примечание: r помещается перед именем файла, чтобы символы в строке имени файла не рассматривались как специальные символы. Например, если в адресе файла есть \ temp, то \ t рассматривается как символ табуляции и возникает ошибка недопустимого адреса. R делает строку необработанной, то есть сообщает, что в строке нет специальных символов. Букву r можно игнорировать, если файл находится в том же каталоге, а адрес не помещается.

файл1 = открыть ( "MyFile.txt " , " w " )

file2 = открыть (r " D: \ Text \ MyFile2.txt " , " w + " )

Здесь file1 создается как объект для MyFile1 и file2 как объект для MyFile2.

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

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

Синтаксис:

File_object.close ()
 

файл1 = открыть ( «MyFile.txt» , «w» )

file1.close ()

Запись в файл

Есть два способа записи в файл.

  1. write (): Вставляет строку str1 в одну строку в текстовый файл.
    File_object.write (str1)
     
  2. writelines (): Для списка строковых элементов каждая строка вставляется в текстовый файл. Используется для одновременной вставки нескольких строк.
    File_object.writelines (L) для L = [str1, str2, str3]
     

Примечание. ‘\ n’ обрабатывается как специальный двухбайтовый символ.

Пример:

файл1 = открыть ( 'myfile.txt' , 'w' )

L = [ "Это Дели \ n" , "Это Париж \ n" , "Это Лондон \ n" ]

s = "Привет \ n"

файл1.запись (и)

file1.writelines (L)

file1.close ()

file1 = открыть ( 'myfile.txt' , 'r' )

print (file1.read ())

file1.close ()

Выход:

Привет
Это Дели
Это париж
Это лондон
 
Добавление к файлу

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

файл1 = открыть ( "myfile.txt" , "w" )

L = [ "Это это Дели \ n " , " Это Париж \ n " , " Это Лондон \ n " ]

file1.Writelines (L)

file1.close ()

file1 = открыть ( "myfile.txt" , "a" )

file1.write ( "Сегодня \ n" )

file1.close ()

file1 = открыть ( "myfile.txt « , « r » )

print ( « Вывод строк чтения после добавления » )

print (file1.чтение ())

печать ()

file1.close ()

file1 = открыть ( "myfile.txt" , "w" )

file1.write ( "Завтра \ n" )

file1.close ()

file1 = открыть ( "myfile.txt " , " r " )

print ( " Вывод строк чтения после записи " )

print (file1.read ())

печать ()

file1.close ()

Выход:

Вывод строк чтения после добавления
Это Дели
Это париж
Это лондон
Сегодня


Вывод строк чтения после записи
Завтра
 
С оператором

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

Синтаксис:

с открытым именем файла в виде файла:
 

L = [ "Это Дели \ n" , "Это Париж \ n" , "Это Лондон \ n " ]

с открытым ( " myfile.txt " , " w " ) как file1:

file1.write ( " Hello \ n " )

file1.writelines ( L)

с открытым ( "myfile.txt" , "r +" ) как файл1:

печать (файл1.чтение ())

Выход:

Привет
Это Дели
Это париж
Это лондон
 

Примечание: Чтобы узнать больше о выписке, нажмите здесь.

7. Ввод и вывод — документация Python 3.9.4

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

7.1. Более простое форматирование вывода

До сих пор мы встречали два способа записи значений: операторов выражения и
функция print () . (Третий способ — использовать метод write ()
файловых объектов; на стандартный выходной файл можно ссылаться как на sys.stdout .
Для получения дополнительной информации см. Справочник по библиотеке.)

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

  • Чтобы использовать форматированные строковые литералы, начните строку
    с f или F перед открывающей кавычкой или тройной кавычкой.
    Внутри этой строки вы можете написать выражение Python между { и }
    символы, которые могут относиться к переменным или буквальным значениям.

     >>> год = 2016
    >>> event = 'Референдум'
    >>> f'Результаты {года} {события} '
    'Итоги референдума 2016 года'
     
  • ул.format () метод строк требует более ручного
    усилие. Вы по-прежнему будете использовать { и } , чтобы отмечать, где переменная
    будут заменены и могут предоставить подробные директивы форматирования,
    но вам также потребуется предоставить информацию для форматирования.

     >>> yes_votes = 42_572_654
    >>> no_votes = 43_132_495
    >>> процент = yes_votes / (yes_votes + no_votes)
    >>> '{: -9} ДА голосов {: 2.2%}'. Формат (yes_votes, процент)
    42572654 ДА голоса 49.67% '
     
  • Наконец, вы можете выполнять всю обработку строк самостоятельно, используя нарезку строк и
    операции конкатенации для создания любого макета, который вы можете себе представить. В
    строковый тип имеет несколько методов, которые выполняют полезные операции для заполнения
    строки с заданной шириной столбца.

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

Функция str () предназначена для возврата представлений значений, которые
довольно удобочитаемый, а repr () предназначен для генерации представлений
который может быть прочитан интерпретатором (или вызовет SyntaxError , если
нет эквивалентного синтаксиса). Для объектов, не имеющих особого
представление для человеческого потребления, str () вернет то же значение, что и
репр () . Многие значения, такие как числа или структуры, такие как списки и
словари имеют одинаковое представление с использованием любой функции.Струны, в
в частности, имеют два различных представления.

Некоторые примеры:

 >>> s = 'Привет, мир.'
>>> ул.
'Привет мир.'
>>> представитель (ы)
"'Привет мир.'"
>>> str (1/7)
'0,14285714285714285'
>>> х = 10 * 3,25
>>> y = 200 * 200
>>> s = 'Значение x равно' + repr (x) + ', а y равно' + repr (y) + '...'
>>> печать (и)
Значение x равно 32,5, а y равно 40000 ...
>>> # Функция repr () строки добавляет строковые кавычки и обратную косую черту:
... hello = 'привет, мир \ n'
>>> привет = repr (привет)
>>> печать (привет)
'привет, мир \ n'
>>> # Аргументом repr () может быть любой объект Python:
... repr ((x, y, ('спам', 'яйца')))
"(32,5, 40000, ('спам', 'яйца'))"
 

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

7.1.1. Форматированные строковые литералы

Форматированные строковые литералы (также называемые f-строками для
short) позволяют включать значение выражений Python внутри строки с помощью
добавляя к строке префикс f или F и записывая выражения как
{выражение} .

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

 >>> импорт математики
>>> print (f'Значение числа пи приблизительно равно {math.pi: .3f}. ')
Значение пи составляет приблизительно 3,142.
 

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

 >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 7678}
>>> для имени, телефона в table.items ():
... print (f '{name: 10} ==> {phone: 10d}')
...
Шёрд ==> 4127
Джек ==> 4098
Dcab ==> 7678
 

Для преобразования значения перед форматированием можно использовать другие модификаторы. '! A' применяет ascii () , '! S' применяет str () и '! R'
применяется repr () :

 >>> животные = 'угри'
>>> print (f'Мое судно на воздушной подушке полно {животных}. ')
Мое судно на воздушной подушке полно угрей.
>>> print (f'Мое судно на воздушной подушке полно {животных! r}. ')
Мое судно на воздушной подушке полно угрей'.
 

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

7.1.2. Метод String format ()

Базовое использование метода str.format () выглядит так:

 >>> print ('Мы те {}, которые говорят "{}!". Format (' рыцари ',' Ни '))
Мы рыцари, которые говорят «Ни!»
 

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

 >>> print ('{0} и {1}'. Формат ('спам', 'яйца'))
спам и яйца
>>> print ('{1} и {0}'. format ('спам', 'яйца'))
яйца и спам
 

Если аргументы ключевого слова используются в методе str.format () , их значения
упоминаются с использованием имени аргумента.

 >>> print ('Эта {еда} есть {прилагательное}.'. Format (
... food = 'spam', прилагательное = 'абсолютно ужасно'))
Этот спам просто ужасен.
 

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

 >>> print ('История {0}, {1} и {other}.'.format (' Билл ',' Манфред ',
                                                       other = 'Георг'))
История Билла, Манфреда и Георга.
 

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

 >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print ('Джек: {0 [Джек]: d}; Шорд: {0 [Шорд]: d};'
... 'Dcab: {0 [Dcab]: d}'. Формат (таблица))
Джек: 4098; Шорд: 4127; Dcab: 8637678
 

Это также можно сделать, передав таблицу в качестве аргументов ключевого слова с «**»
обозначение.

 >>> table = {'Sjoerd': 4127, 'Jack': 4098, 'Dcab': 8637678}
>>> print ('Jack: {Jack: d}; Sjoerd: {Sjoerd: d}; Dcab: {Dcab: d}'. format (** таблица))
Джек: 4098; Шорд: 4127; Dcab: 8637678
 

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

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

 >>> для x в диапазоне (1, 11):
... print ('{0: 2d} {1: 3d} {2: 4d}'. format (x, x * x, x * x * x))
...
 1 1 1
 2 4 8
 3 9 27
 4 16 64
 5 25 125
 6 36 216
 7 49 343
 8 64 512
 9 81 729
10 100 1000
 

Полный обзор форматирования строк с помощью str.format () см.
Синтаксис строки формата.

7.1.3. Форматирование строки вручную

Вот та же таблица квадратов и кубов, отформатированная вручную:

 >>> для x в диапазоне (1, 11):
... print (repr (x) .rjust (2), repr (x * x) .rjust (3), end = '')
... # Обратите внимание на использование 'end' в предыдущей строке
... печать (repr (x * x * x) .rjust (4))
...
 1 1 1
 2 4 8
 3 9 27
 4 16 64
 5 25 125
 6 36 216
 7 49 343
 8 64 512
 9 81 729
10 100 1000
 

(обратите внимание, что один пробел между каждым столбцом был добавлен
способ print () работает: он всегда добавляет пробелы между своими аргументами.)

Метод str.rjust () строковых объектов выравнивает строку по правому краю в
поле заданной ширины, заполняя его пробелами слева. Есть
аналогичные методы str.ljust () и str.center () . Эти методы делают
ничего не пишут, они просто возвращают новую строку. Если входная строка слишком
long, они не усекают его, а возвращают без изменений; это испортит ваш
расположение столбцов, но обычно это лучше, чем альтернатива, которая была бы
ложь о стоимости.(Если вам действительно нужно усечение, вы всегда можете добавить
операция среза, как в x.ljust (n) [: n] .)

Существует еще один метод, str.zfill () , который заполняет числовую строку на
осталось с нулями. Он разбирается в плюсах и минусах:

 >>> '12'.zfill (5)
"00012"
>>> '-3.14'.zfill (7)
'-003,14'
>>> '3.141559'.zfill (5)
"3.141559"
 

7.1.4. Старое форматирование строки

Оператор% (по модулю) также может использоваться для форматирования строк.Учитывая 'строку'
% значений
, экземпляры % в строке заменяются нулем или более
элементы значений . Эта операция широко известна как строка
интерполяция. Например:

 >>> импорт математики
>>> print ('Значение пи примерно% 5.3f.'% math.pi)
Значение пи составляет приблизительно 3,142.
 

Дополнительную информацию можно найти в разделе «Форматирование строк в стиле printf».

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

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

 >>> f = open ('рабочий файл', 'w')
 

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

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

В текстовом режиме при чтении по умолчанию выполняется преобразование строки, зависящей от платформы.
окончания ( \ n в Unix, \ r \ n в Windows) до \ n . При записи в
текстовый режим, по умолчанию вхождения \ n обратно в
окончание строк, зависящее от платформы. Эта закулисная модификация
в файл данных подходит для текстовых файлов, но приведет к повреждению двоичных данных, подобных этому в
JPEG или EXE файлов.Будьте очень осторожны при использовании двоичного режима, когда
чтение и запись таких файлов.

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

 >>> с open ('workfile') как f:
... read_data = f.read ()

>>> # Мы можем проверить, что файл был автоматически закрыт.>>> f.closed
Правда
 

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

Предупреждение

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

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

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

7.2.1. Методы файловых объектов

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

Чтобы прочитать содержимое файла, вызовите f.read (size) , который читает некоторое количество
data и возвращает их в виде строки (в текстовом режиме) или байтового объекта (в двоичном режиме).
размер - необязательный числовой аргумент. Если размер опущен или отрицателен,
будет прочитано и возвращено все содержимое файла; это ваша проблема, если
размер файла вдвое превышает объем памяти вашего компьютера. В противном случае не более размер
символов (в текстовом режиме) или размером байт (в двоичном режиме) считываются и возвращаются.Если достигнут конец файла, f.read () вернет пустой
строка ( '' ).

 >>> f.read ()
"Это весь файл. \ N"
>>> f.read ()
''
 

f.readline () читает одну строку из файла; символ новой строки ( \ n )
остается в конце строки и опускается только в последней строке
file, если файл не заканчивается новой строкой. Это делает возвращаемое значение
однозначный; если f.readline () возвращает пустую строку, конец файла
достигнут, а пустая строка представлена ​​ '\ n' , строка
содержащий только одну новую строку.

 >>> f.readline ()
'Это первая строка файла. \ N'
>>> f.readline ()
'Вторая строка файла \ n'
>>> f.readline ()
''
 

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

 >>> для строки в f:
... печать (строка, конец = '')
...
Это первая строка файла.
Вторая строка файла
 

Если вы хотите прочитать все строки файла в списке, вы также можете использовать
список (f) или f.Чтение линий () .

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

 >>> f.write ('Это тест \ n')
15
 

Остальные типы объектов необходимо преобразовать - либо в строку (в текстовом режиме)
или байтовый объект (в двоичном режиме) - перед их записью:

 >>> value = ('ответ', 42)
>>> s = str (value) # преобразовать кортеж в строку
>>> е.написать (а)
18
 

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

Чтобы изменить положение файлового объекта, используйте f.seek (смещение, откуда) . Позиция вычисляется
от добавления смещения к точке отсчета; точка отсчета выбирается
, откуда аргумент. , откуда значение 0 отсчитывает от начала
файла, 1 использует текущую позицию файла, а 2 использует конец файла как
ориентир., откуда можно опустить и по умолчанию 0, используя
начало файла в качестве ориентира.

 >>> f = open ('рабочий файл', 'rb +')
>>> f.write (b'0123456789abcdef ')
16
>>> f.seek (5) # Перейти к 6-му байту в файле
5
>>> f.read (1)
b'5 '
>>> f.seek (-3, 2) # Перейти к 3-му байту до конца
13
>>> f.read (1)
b'd '
 

В текстовых файлах (открытых без b в строке режима) выполняется поиск только
относительно начала файла разрешены (исключение - поиск
до самого конца файла с seek (0, 2) ), и единственными допустимыми значениями смещения являются
те, что вернулись из f.tell () или ноль. Любое другое значение смещения дает
неопределенное поведение.

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

7.2.2. Сохранение структурированных данных с помощью

json

Строки можно легко записывать и читать из файла. Числа занимают немного больше
усилия, поскольку метод read () возвращает только строки, которые должны
передаваться в функцию типа int () , которая принимает строку типа '123'
и возвращает его числовое значение 123.Если вы хотите сохранить более сложные данные
типы, такие как вложенные списки и словари, парсинг и сериализация вручную
усложняется.

Вместо того, чтобы заставлять пользователей постоянно писать и отлаживать код для экономии
сложные типы данных в файлы, Python позволяет использовать популярные данные
формат обмена называется JSON (JavaScript Object Notation). Стандартный модуль под названием json может принимать Python
иерархии данных и преобразовать их в строковые представления; этот процесс
вызвал сериализуя .Реконструкция данных из строкового представления
называется десериализацией . Между сериализацией и десериализацией
строка, представляющая объект, могла быть сохранена в файле или данных, или
отправлено через сетевое соединение на какую-то удаленную машину.

Примечание

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

Если у вас есть объект размером x , вы можете просмотреть его строковое представление JSON с
простая строка кода:

 >>> импортировать json
>>> json.дампы ([1, 'простой', 'список'])
'[1, «простой», «список»] »
 

Другой вариант функции dumps () , называемый dump () ,
просто сериализует объект в текстовый файл. Итак, если f - это
объект текстового файла, открытый для записи, мы можем сделать это:

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

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

См. Также

pickle - модуль pickle

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

Чтение и запись файлов на Python (Руководство) - Real Python