Python сохранить в файл: Работа с файлами в Python

Содержание

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

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

Как читать файлы

Python содержит в себе функцию, под названием «open», которую можно использовать для открытия файлов для чтения. Создайте текстовый файл под названием test.txt и впишите:

This is test file
line 2
line 3
this line intentionally left lank

This is test file

line 2

line 3

this line intentionally left lank

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

handle = open(«test.txt»)
handle = open(r»C:\Users\mike\py101book\data\test.txt», «r»)

handle = open(«test.txt»)

handle = open(r»C:\Users\mike\py101book\data\test.txt», «r»)

В первом примере мы открываем файл под названием test.txt в режиме «только чтение». Это стандартный режим функции открытия файлов. Обратите внимание на то, что мы не пропускаем весь путь к файлу, который мы собираемся открыть в первом примере. Python автоматически просмотрит папку, в которой запущен скрипт для text.txt. Если его не удается найти, вы получите уведомление об ошибке IOError. Во втором примере показан полный путь к файлу, но обратите внимание на то, что он начинается с «r». Это значит, что мы указываем Python, чтобы строка обрабатывалась как исходная. Давайте посмотрим на разницу между исходной строкой и обычной:

>>> print(«C:\Users\mike\py101book\data\test.txt»)
C:\Users\mike\py101book\data est.txt

>>> print(r»C:\Users\mike\py101book\data\test.txt»)
C:\Users\mike\py101book\data\test.txt

>>> print(«C:\Users\mike\py101book\data\test.txt»)

C:\Users\mike\py101book\data est.txt

>>> print(r»C:\Users\mike\py101book\data\test.txt»)

C:\Users\mike\py101book\data\test.txt

Как видно из примера, когда мы не определяем строку как исходную, мы получаем неправильный путь. Почему это происходит? Существуют определенные специальные символы, которые должны быть отображены, такие как “n” или “t”. В нашем случае присутствует “t” (иными словами, вкладка), так что строка послушно добавляет вкладку в наш путь и портит её для нас. Второй аргумент во втором примере это буква “r”. Данное значение указывает на то, что мы хотим открыть файл в режиме «только чтение». Иными словами, происходит то же самое, что и в первом примере, но более явно. Теперь давайте, наконец, прочтем файл!

Введите нижеизложенные строки в скрипт, и сохраните его там же, где и файл test.txt.

handle = open(«test.txt», «r»)
data = handle.read()
print(data)
handle.close()

handle = open(«test.txt», «r»)

data = handle.read()

print(data)

handle.close()

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

Давайте обратим внимание на различные способы чтения файлов.

handle = open(«test.txt», «r»)
data = handle.readline() # read just one line
print(data)
handle.close()

handle = open(«test.txt», «r»)

data = handle.readline() # read just one line

print(data)

handle.close()

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

handle = open(«test.txt», «r»)
data = handle.readlines() # read ALL the lines!
print(data)
handle.close()

handle = open(«test.txt», «r»)

data = handle.readlines() # read ALL the lines!

print(data)

handle.close()

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

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

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

Как читать файл по частям

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

handle = open(«test.txt», «r»)

for line in handle:
print(line)

handle.close()

handle = open(«test.txt», «r»)

for line in handle:

print(line)

handle.close()

Таким образом мы открываем файл в дескрипторе в режиме «только чтение», после чего используем цикл для его повторения. Стоит обратить внимание на то, что цикл можно применять к любым объектам Python (строки, списки, запятые, ключи в словаре, и другие). Весьма просто, не так ли? Попробуем прочесть файл по частям:

handle = open(«test.txt», «r»)

while True:
data = handle.read(1024)
print(data)

if not data:
break

handle = open(«test.txt», «r»)

while True:

data = handle.read(1024)

print(data)

if not data:

break

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

Как читать бинарные (двоичные) файлы

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

handle = open(«test.pdf», «rb»)

Мы изменили способ доступа к файлу на rb, что значит read-binaryy. Стоит отметить то, что вам может понадобиться читать бинарные файлы, когда вы качаете PDF файлы из интернете, или обмениваетесь ими между компьютерами.

Пишем в файлах в Python

Как вы могли догадаться, следуя логике написанного выше, режимы написания файлов в Python это “w” и “wb” для write-mode и write-binary-mode соответственно. Теперь давайте взглянем на простой пример того, как они применяются.
ВНИМАНИЕ: использование режимов “w” или “wb” в уже существующем файле изменит его без предупреждения. Вы можете посмотреть, существует ли файл, открыв его при помощи модуля ОС Python.

handle = open(«output.txt», «w»)
handle.write(«This is a test!»)
handle.close()

handle = open(«output.txt», «w»)

handle.write(«This is a test!»)

handle.close()

Вот так вот просто. Все, что мы здесь сделали – это изменили режим файла на “w” и указали метод написания в файловом дескрипторе, чтобы написать какой-либо текст в теле файла. Файловый дескриптор также имеет метод writelines (написание строк), который будет принимать список строк, который дескриптор, в свою очередь, будет записывать по порядку на диск.

Выбирайте дешевые лайки на видео в YouTube на сервисе https://doctorsmm.com/. Здесь, при заказе, Вам будет предоставлена возможность подобрать не только недорогую цену, но и выгодные персональные условия приобретения. Торопитесь, пока на сайте действуют оптовые скидки!

Использование оператора «with»

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

with open(«test.txt») as file_handler:
for line in file_handler:
print(line)

with open(«test.txt») as file_handler:

for line in file_handler:

print(line)

Синтаксис для оператора with, на первый взгляд, кажется слегка необычным, однако это вопрос недолгой практики. Фактически, все, что мы делаем в данном примере, это:

handle = open(«test.txt»)

Меняем на это:

with open(«test.txt») as file_handler:

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

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

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

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

try:

file_handler = open(«test.txt»)

for line in file_handler:

print(line)

except IOError:

print(«An IOError has occurred!»)

finally:

file_handler.close()

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

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

try:

with open(«test.txt») as file_handler:

for line in file_handler:

print(line)

except IOError:

print(«An IOError has occurred!»)

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

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

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

Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

E-mail: [email protected]

Образование
Universitatea Tehnică a Moldovei (utm.md)

2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

Python скрипт должен сохранить вывод в текстовый файл

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

Скрипт отлично работает в консоли IDLE, печатает нажатые клавиши и регистрирует любые изменения в текущем активном окне.

from pynput.keyboard import Key, Listener
import time
from win32gui import GetWindowText, GetForegroundWindow
import datetime
from threading import Thread

def on_press(key):
    print ('{0} pressed'.format(key))   

def on_release(key):
    ('{0} release'.format(key))
    if key == Key.esc:
        return False

def get_titles():
    current_title = None
    while True:
        moment2 = datetime.datetime.now().strftime("%d-%b-%Y [ %H:%M:%S ]")
        new_title = GetWindowText(GetForegroundWindow())
        if new_title != current_title:
            if len(new_title) > 0:
                #logging.info(" Moved to : " + new_title)
                current_title = new_title
                time.sleep(0.1)
                #print(new_title)
                ff= (moment2 + " : " +  "Moved T0 : "+ new_title)
                print (ff)

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

python

text

save

output

Поделиться

Источник

K.Meleo

21 декабря 2018 в 12:13

3 ответа

Python имеет собственную функцию open() , не требующую импорта, которая позволяет обрабатывать файлы. Эта функция «loads» файл в память, и может быть установлен в различных режимах:

open("filename.txt", "a"), добавление содержимого в новую строку;
open("filename.txt", "w"), перезапись содержимого; и
open("filename.txt", "r"), установив его только для чтения.
open("filename.txt", "x"), чтобы создать файл.

Вы можете добавить » + » к каждому из этих режимов («a+», «w+»), если хотите, чтобы файл был создан, если он еще не существует.

Вы определяете файл в памяти переменной как таковой: a = open("filename.txt", "w"), а затем можете text = a.read() загрузить содержимое файла в строку или a.readlines() загрузить строки в массив, разбитый на \n .

Используйте a.write("Your desired output") для сохранения содержимого в файл, если файл находится в режиме записи или добавления.

Редактировать:

Старайтесь открывать файлы только до тех пор, пока они действительно необходимы.

with open("filename.txt", "r") as f:
    file_contents = f.read()
    # file_contents = "This file contains\nvery important information"

    file_lines = f.readlines()
    # file_lines = ["This file contains", "very important information"]
    # Similar to file_lines = file_contents.split("\n")

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

Поделиться

mazunki

21 декабря 2018 в 12:23

Просто добавьте

with open('textfile.txt', 'a+') as f:
  f.write(ff)

Опция a предназначена для добавления к файлу, а + означает, что если файла там нет, просто создайте его с указанным именем.

EDIT:

def on_press(key):
    print ('{0} pressed'.format(key))
    with open('textfile.txt', 'a+') as f:
      f.write(ff)

EDIT 2:

def on_press(key):
    print ('{0} pressed'.format(key))
    k = key + '\n'
    with open('textfile.txt', 'a+') as f:
      f.write(key) 

# and in get_titles()
ff= (moment2 + " : " +  "Moved T0 : "+ new_title + '\n')
with open('textfile.txt', 'a+') as f:
      f.write(ff)

Поделиться

Novak

21 декабря 2018 в 12:24

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

python your_script.py > path_to_output_file/outpot.txt

если ‘>’ не сработает, то попробуйте ‘>>’

Поделиться

Nikulsinh

21 декабря 2018 в 12:24

Как сохранить выходные данные в telnet логи в текстовый файл в python
Я изучаю python и пытаюсь подключить свой спутниковый декодер с помощью telnet. Когда я попытался подключить свое устройство через скрипт telnet python, я смог успешно подключиться к этому устройству. Но я хочу захватить/сохранить, а также прочитать выходные данные и журналы устройства…
Как написать soapUI groovy скрипт log в текстовый файл
Я должен написать Groovy скрипт входа в текстовый файл, я могу написать запрос и ответ любого шага Soap, используя context.expand . Для написания тестового запроса и ответа я использую: def request = context.expand(‘${SoapRequest#Request}’) new File (D:/RequestFile.txt).write(request) Что я хочу,…

Сохранение, загрузка и повторный вызов работы в окне Python—Справка

Сохранение работы

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

Содержимое окна Python можно сохранить в файл Python или текстовом файе. Щелкните окно Python правой кнопкой мыши и выберите Сохранить как (Save As), чтобы сохранить код либо в файл Python (.py), либо в текстовый файл (.txt). При сохранении в файл Python можно сохранить только код. При сохранении в текстовом файле все содержимое окна Python, включая код, возвращаемые сообщения и командную строку (>>>), будет записано в выходной файл.

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

Загрузка в окно Python

Окно Python является интерактивным интерпретатором, который удобен для быстрого выполнения инструментов геообработки или других команд Python. Однако код, который уже был написан и сохранен в автономный скрипт или в файл Python, также можно загрузить в окно Python, изменить и выполнить. Ниже показан простой скрипт, который просматривает класс объектов и поле и создает уникальный список значений поля. Это достаточно простой пример, но ввод вручную всех 13 его строк в окно Python может занять продолжительное время. Вместо этого щелкните правой кнопкой в окне Python и выберите Загрузить (Load). Выбранный вами код (сохраненный в автономном скрипте или как файл Python) будет немедленно загружен в окно Python. После загрузки в окно Python можно отредактировать положение класса объектов, имя поля или синтаксис, затем выполнить код, поместив курсор в конце кода и нажав клавишу ENTER.

Создает список уникальных значений поля на основе класса объектов и имени поля.

import arcpy
featureclass = "C:/data/county.gdb/hospital"
field = "Zip"

valueList = []
rows = arcpy.da.SearchCursor(featureclass, [field])
for row in rows:
    valueList.append(row[0])

uniqueSet = set(valueList)
uniqueList = list(uniqueSet)
uniqueList.sort()

print(uniqueList)

Повторный вызов кода Python

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

Отзыв по этому разделу?

Работа с файлами в python. Чтение и запись в файл ~ PythonRu

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

Файлы Python

Файл — это всего лишь набор данных, сохраненный в виде последовательности битов на компьютере. Информация хранится в куче данных (структура данных) и имеет название «имя файла» (filename).

В Python существует два типа файлов:

Текстовые
Бинарные

Текстовые файлы

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

Текст может храниться в двух форматах: (.txt) — простой текст и (.rtf) — «формат обогащенного текста».

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

В бинарных файлах данные отображаются в закодированной форме (с использованием только нулей (0) и единиц (1) вместо простых символов). В большинстве случаев это просто последовательности битов.

Они хранятся в формате .bin.

Любую операцию с файлом можно разбить на три крупных этапа:

Открытие файла
Выполнение операции (запись, чтение)
Закрытие файла

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

Метод open()

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

Синтаксис следующий:

f = open(file_name, access_mode)

Где,

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

Режим	Описание
r	Только для чтения.
w	Только для записи. Создаст новый файл, если не найдет с указанным именем.
rb	Только для чтения (бинарный).
wb	Только для записи (бинарный). Создаст новый файл, если не найдет с указанным именем.
r+	Для чтения и записи.
rb+	Для чтения и записи (бинарный).
w+	Для чтения и записи. Создаст новый файл для записи, если не найдет с указанным именем.
wb+	Для чтения и записи (бинарный). Создаст новый файл для записи, если не найдет с указанным именем.
a	Откроет для добавления нового содержимого. Создаст новый файл для записи, если не найдет с указанным именем.
a+	Откроет для добавления нового содержимого. Создаст новый файл для чтения записи, если не найдет с указанным именем.
ab	Откроет для добавления нового содержимого (бинарный). Создаст новый файл для записи, если не найдет с указанным именем.
ab+	Откроет для добавления нового содержимого (бинарный). Создаст новый файл для чтения записи, если не найдет с указанным именем.

Пример

Создадим текстовый файл example.txt и сохраним его в рабочей директории.

Следующий код используется для его открытия.

f = open('example.txt','r')  
fp = open('C:/xyz.txt','r')

В этом примере f — переменная-указатель на файл example.txt.

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

>>> print(*f) 
This is a text file.
>>> print(f) 
<_io.TextIOWrapper name='example.txt' mode='r' encoding='cp1252'>

Стоит обратить внимание, что в Windows стандартной кодировкой является cp1252, а в Linux — utf-08.

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

Метод close()

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

Существуют следующие способы:

Способ №1

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

f = open('example.txt','r')

f.close()

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

Способ №2

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

Без него программа завершается некорректно.

Вот как сделать это исключение:

f = open('example.txt','r')
try:
   
finally:
   f.close()

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

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

Способ №3

Инструкция with

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

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

Вот как это реализовать в коде.

with open('example.txt') as f:

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

В Python файлы можно читать или записывать информацию в них с помощью соответствующих режимов.

Функция read()

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

Синтаксис

file.read(size)

Где,

file = объект файла
size = количество символов, которые нужно прочитать. Если не указать, то файл прочитается целиком.

Пример

>>> f = open('example.txt','r')
>>> f.read(7)  
'This is '

Интерпретатор прочитал 7 символов файла и если снова использовать функцию read(), то чтение начнется с 8-го символа.

>>> f.read(7)  
' a text'

Функция readline()

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

Пример

Создадим файл test.txt с нескольким строками:

This is line1.
This is line2.
This is line3.

Посмотрим, как функция readline() работает в test.txt.

>>> x = open('test.txt','r')
>>> x.readline()  
This is line1.
>>> x.readline(2)  
This is line2.
>>> x.readlines()  
['This is line1.','This is line2.','This is line3.']

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

Функция write()

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

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

Синтаксис

file.write(string)

Пример

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

>>> f = open('xyz.txt','w')  
>>> f.write('Hello \n World')  
Hello
World
>>> f.close()

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

Функция rename()

Функция rename() используется для переименовывания файлов в Python. Для ее использования сперва нужно импортировать модуль os.

Синтаксис следующий.

import os
os.rename(src,dest)

Где,

src = файл, который нужно переименовать
dest = новое имя файла

Пример

>>> import os
>>> 
>>> os.rename("xyz.txt","abc.txt")

Текущая позиция в файлах Python

В Python возможно узнать текущую позицию в файле с помощью функции tell(). Таким же образом можно изменить текущую позицию командой seek().

Пример

>>> f = open('example.txt')  
>>> f.read(4)  
This
>>> f.tell()  
4
>>> f.seek(0,0)

Методы файла в Python


`file.close()`	закрывает открытый файл
`file.fileno()`	возвращает целочисленный дескриптор файла
`file.flush()`	очищает внутренний буфер
`file.isatty()`	возвращает True, если файл привязан к терминалу
`file.next()`	возвращает следующую строку файла
`file.read(n)`	чтение первых n символов файла
`file.readline()`	читает одну строчку строки или файла
`file.readlines()`	читает и возвращает список всех строк в файле
file.seek(offset[,whene])	устанавливает текущую позицию в файле
`file.seekable()`	проверяет, поддерживает ли файл случайный доступ. Возвращает `True`, если да
`file.tell()`	возвращает текущую позицию в файле
`file.truncate(n)`	уменьшает размер файл. Если n указала, то файл обрезается до n байт, если нет — до текущей позиции
`file.write(str)`	добавляет строку `str` в файл
`file.writelines(sequence)`	добавляет последовательность строк в файл

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

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

Чтобы не соскучится, мы покажем несколько способов внесения данных в файл и наглядно увидим результат. Чтобы открыть файл для записи или же создать его, мы воспользуемся функцией open(filename, mod) и в качестве второго параметрам mod укажем значение w т.е. (write) запись. Если файл с указанным названием filename не существует — он будет создан.

Создаем новый файл в Python

# -*- coding: utf-8 -*-
my_file = open('snake.txt', 'w')
 
# Закрываем файл
my_file.close()

После выполнения данного скрипта, по указанному нами пути будет создан новый файл snake.txt если файл не был создан то нужно проверить права доступа на папку. Стоит учесть, что если файл snake.txt существовал ранее, то после открытия его функцией open() и мод W, тогда содержимое файла удаляется. Если вы хотите добавить что-то в конце, то следует использовать мод ‘a+’.

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

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

# -*- coding: utf-8 -*-
my_file = open('snake.txt', 'w')
 
text_for_file = 'Some text here...'
my_file.write(text_for_file)
 
my_file.close()

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

Заменяем данные из определенной строки файла

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

Изначальный файл snake.txt

Я
Программа
написанная
в
Python
3

Заменяем 5-ю строку со значением ‘Python’ на значение ‘Питон’

# -*- coding: utf-8 -*-
# Открываем файл только для чтения
f = open('snake.txt', 'r')
lines = f.readlines()
lines[4] = 'Питон' + '\n'
 
# Закрываем файл
f.close()
 
# Открываем файл для записи
save_changes = open('snake.txt', 'w')
 
# Сохраняем список строк
save_changes.writelines(lines)
 
# Закрываем файл
save_changes.close()

Финальный вид файла snake.txt

Я
Программа
написанная
в
Питон
3

Копирование файлов в Python

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

# -*- coding: utf-8 -*-
# Открываем файл только для чтения
old_image = open('temp/pro.jpeg', 'r').read()
 
# Создаем новый файл
new_image = open('new_pro.jpeg', 'w')
 
# Сохраняем данные старой картинки в новую
new_image.write(old_image)
new_image.close()

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

python — Как сохранить список в файл и прочитать его как тип списка?

Допустим, у меня есть оценка в списке = [1,2,3,4,5], и она меняется во время работы моей программы. Как я могу сохранить его в файл, чтобы при следующем запуске программы я мог получить доступ к измененному списку как к типу списка?

Я пытался:

score=[1,2,3,4,5]

with open("file.txt", 'w') as f:
    for s in score:
        f.write(str(s) + '\n')

with open("file.txt", 'r') as f:
    score = [line.rstrip('\n') for line in f]


print(score)

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

Oceanescence

2 Янв 2015 в 19:47

7 ответов

Лучший ответ

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

score = [1,2,3,4,5]

with open("file.txt", "w") as f:
    for s in score:
        f.write(str(s) +"\n")

with open("file.txt", "r") as f:
  for line in f:
    score.append(int(line.strip()))

Таким образом, элементы в файле читаются как целые числа, несмотря на то, что хранятся в файле в виде строк.

Oceanescence
3 Фев 2015 в 17:34

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

sampleList1=['z','x','a','b']
sampleList2=[[1,2],[4,5]]

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

def saveList(myList,filename):
    # the filename should mention the extension 'npy'
    np.save(filename,myList)
    print("Saved successfully!")

И вот функция для загрузки файла в список

def loadList(filename):
    # the filename should mention the extension 'npy'
    tempNumpyArray=np.load(filename)
    return tempNumpyArray.tolist()

Рабочий пример

>>> saveList(sampleList1,'sampleList1.npy')
>>> Saved successfully!
>>> saveList(sampleList2,'sampleList2.npy')
>>> Saved successfully!

# loading the list now 
>>> loadedList1=loadList('sampleList1.npy')
>>> loadedList2=loadList('sampleList2.npy')

>>> loadedList1==sampleList1
>>> True

>>> print(loadedList1,sampleList1)

>>> ['z', 'x', 'a', 'b'] ['z', 'x', 'a', 'b']

Manu Gond
20 Июн 2019 в 17:33

Я использую панды.

import pandas as pd
x = pd.Series([1,2,3,4,5])
x.to_excel('temp.xlsx')
y = list(pd.read_excel('temp.xlsx')[0])
print(y)

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

Manideep Karthik
24 Дек 2018 в 09:16

Что мне не понравилось во многих ответах, так это то, что он делает слишком много системных вызовов, записывая в строку файла каждую строку. Imho, лучше всего присоединиться к списку с помощью ‘\ n’ (возврат строки), а затем записать его только один раз в файл:

mylist = ["abc", "def", "ghi"]
myfile = "file.txt"
with open(myfile, 'w') as f:
    f.write("\n".join(mylist))

А затем открыть его и получить свой список снова:

with open(myfile, 'r') as f:
    mystring = f.read()
my_list = mystring.split("\n")

Antonin GAVREL
3 Янв 2020 в 22:09

Вы также можете использовать модуль Python json:

import json

score=[1,2,3,4,5]

with open("file.json", 'w') as f:
    # indent=2 is not needed but makes the file more 
    # human-readable for more complicated data
    json.dump(score, f, indent=2) 

with open("file.json", 'r') as f:
    score = json.load(f)

print(score)

Преимущество использования JSON заключается в том, что:

Файл читается человеком
Непитоновские программы могут читать и понимать файл json
Вы можете буквально сохранить любой список / словарь в Python в JSON (если ни одно из значений не является объектами / функциями)

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

Jay Mody
3 Янв 2020 в 22:29

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

>>> score = [1,2,3,4,5]
>>> 
>>> with open('file.py', 'w') as f:
...   f.write('score = %s' % score)
... 
>>> from file import score as my_list
>>> print(my_list)
[1, 2, 3, 4, 5]

Mike McKerns
2 Янв 2015 в 17:12

Если вы не хотите использовать pickle, вы можете сохранить список в виде текста и затем оценить его:

data = [0,1,2,3,4,5]
with open("test.txt", "w") as file:
    file.write(str(data))

with open("test.txt", "r") as file:
    data2 = eval(file.readline())

# Let's see if data and types are same.
print(data, type(data), type(data[0]))
print(data2, type(data2), type(data2[0]))

[0, 1, 2, 3, 4, 5] class ‘list’ class ‘int’
[0, 1, 2, 3, 4, 5] class ‘list’ class ‘int’

Sarper Bilazer
10 Мар 2018 в 13:28

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Поиск строки

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

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

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

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

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

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

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

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

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

Как создавать, открывать, добавлять, читать, писать

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

В этом руководстве по обработке файлов в Python мы узнаем:

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

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

Синтаксис функции открытого файла Python

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

Здесь

filename: дает имя файла, который был открыт файловым объектом.
mode: атрибут файлового объекта сообщает вам, в каком режиме был открыт файл.

Более подробная информация об этих режимах объясняется ниже

Как создать текстовый файл в Python

с Python для записи в файл, вы можете создать файл.текстовые файлы (guru99.txt) с помощью кода, который мы продемонстрировали здесь:

Шаг 1)

f = open ("guru99.txt", "w +")

Мы объявили переменную f для открытия файла с именем guru99.txt. Open принимает 2 аргумента: файл, который мы хотим открыть, и строку, представляющую типы разрешений или операций, которые мы хотим выполнить с файлом.
Здесь мы использовали букву «w» в нашем аргументе, которая указывает Python на запись в файл. и он создаст файл, если он не существует в библиотеке
Знак плюс указывает как чтение, так и запись для операции создания файла Python.

Шаг 2)

для i в диапазоне (10):
     f.write ("Это строка% d \ r \ n"% (i + 1))

У нас есть цикл for, который работает с диапазоном из 10 чисел.
Использование функции записи для ввода данных в файл.
Результат, который мы хотим повторить в файле, — это «это номер строки», который мы объявляем с помощью функции записи Python в текстовый файл, а затем процента d (отображает целое число)
Итак, в основном мы вводим номер строки, который мы пишут, затем помещают его в символ возврата каретки и новый строчный символ

Шаг 3)

f.close ()

Это закроет экземпляр сохраненного файла guru99.txt

Вот результат после выполнения кода для Python create file

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

Как добавить в файл в Python

Вы также можете добавить / добавить новый текст к уже существующему файлу или новому файлу.

Шаг 1)

 f = open ("guru99.txt", "a +")

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

Шаг 2)

для i в диапазоне (2):
     f.write ("Добавленная строка% d \ r \ n"% (i + 1))

Это запишет данные в файл в режиме добавления.

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

Как читать файлы в Python

Вы можете прочитать файл в Python, позвонив.txt в «режиме чтения» (r).

Шаг 1) Открыть файл в режиме чтения

f = open ("guru99.txt", "r")

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

if f.mode == 'r':

Шаг 3) Используйте f.read для чтения данных файла и сохранения его в переменном содержимом для чтения файлов в Python

content = f.read ()

Шаг 4) Распечатать содержимое для текстового файла чтения Python

Вот результат примера файла чтения Python:

Как читать файл построчно в Python

Вы можете также прочтите ваш.txt построчно, если ваши данные слишком велики для чтения. Код readlines () разделит ваши данные в удобном для чтения режиме.

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

Файловые режимы в Python

Ниже приведены различные файловые режимы в Python :

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

Вот полный код для Python print () в примере файла

Python 2 Пример

def main ():
     f = open ("guru99.txt", "w +")
     # f = open ("guru99.txt", "a +")
     для i в диапазоне (10):
         f.write ("Это строка% d \ r \ n"% (i + 1))
     f.Закрыть()
     # Откройте файл и прочтите его содержимое
     # f = open ("guru99.txt", "r")
     # если f.mode == 'r':
     # contents = f.read ()
     # распечатать содержимое
     # или readlines считывает отдельную строку в список
     #fl = f.readlines ()
     # для x in fl:
     #print x
если __name __ == "__main__":
  main ()

Пример Python 3

Ниже показан другой пример Python print () в файл:

def main ():
    f = open ("guru99.txt "," w + ")
    # f = open ("guru99.txt", "a +")
    для i в диапазоне (10):
         f.write ("Это строка% d \ r \ n"% (i + 1))
    f.close ()
    # Откройте файл и прочтите его содержимое
    # f = open ("guru99.txt", "r")
    #if f.mode == 'r':
    # contents = f.read ()
    # print (содержимое)
    # или readlines считывает отдельную строку в список
    #fl = f.readlines ()
    # для x in fl:
    #print (x)
если __name __ == "__main__":
  main ()

Сводка

Python позволяет читать, записывать и удалять файлы
Используйте функцию open («filename», «w +») для создания текстового файла Python.Знак + сообщает интерпретатору Python для открытого текстового файла Python с разрешениями на чтение и запись.
Чтобы добавить данные в существующий файл или выполнить операцию печати Python в файл, используйте команду open («Имя файла», « a »).
Используйте функцию чтения файла Python для чтения ВСЕГО содержимого файла.
Используйте функция readlines для чтения содержимого файла по очереди.

Сохранение текста, JSON и CSV в файл в Python

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

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

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

Синтаксис:

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

Параметры:

Имя_файла: Имя файла, который необходимо открыть.
Access_Mode: Режимы доступа определяют тип операций, возможных в открытом файле.

Ниже приведены наиболее часто используемые режимы доступа:

Только чтение («r»): Открыть текстовый файл для чтения.
Только запись («w»): Откройте файл для записи.
Только добавление (‘a’): Откройте файл для записи. Записываемые данные будут вставлены в конце после существующих данных.
Чтение и запись («r +»): Откройте файл для чтения и записи.

Примечание: По умолчанию Python предполагает режим доступа как чтение, т.е. («r»)

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

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

file1.close ()

Примечание: Дополнительные сведения см. в разделе «Открытие файла в Python».

Сохранение текстового файла в Python

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

Пример:

файл = открыть ( 'read.txt' ,

файл .write ( 'Welcome to Geeks for Geeks' )

файл .close ()

Выход:

с

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

Синтаксис:

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

Пример:

с открытым ( 'прочитано.txt ' , ' w ' ) как файл :

книги = [ ' Добро пожаловать \ n ' , 0 9000 'Компьютерщики \ n' ,

'до \ n' ,

'Компьютерщики \ n' ,

'для \ n ,

'Компьютерщики \ n' ,

'мир \ n' ]

файл .строки записи ( "% s \ n" % данные для данных в книгах)

Выход:

Примечание: Информацию см. в разделе Запись в файл на Python.

Сохранение CSV-файла в Python

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

Чтобы сохранить файл CSV:

Во-первых, нам нужно импортировать библиотеку csv.
Затем откройте файл, как обычно, но вместо записи содержимого в объект read_file мы создаем новый объект с именем read_writer.
Этот объект предоставляет нам метод writelines () , который позволяет нам за один раз разместить все данные строки внутри ввода.

Пример:

импорт csv

поля ' = = 'Филиал' , 'Год' , 'CGPA' ]

строк = [[ 'Nikhil' , COE ' , ' 2 ' , ' 9.0 ' ],

[ ' Санчит ' , ' COE ' , ' 2 ' , ' 9,1 ' ],

[ 'Адитья' , 'IT' , '2' , '9,3' ],

[ 'Sagar' , 'SE' , '1' , '9.5 ' ],

[ ' Prateek ' , ' MCE ' , ' 3 ' , ' 7,8 ' ],

[ 'Сахил' , 'EP' , '2' , '9,1' ]]

filename = "University_records.csv "

с открытыми (имя файла, 'w' ) как csvfile:

csvwriter .csvwriter .csvwriter . csvfile)

csvwriter.writerow (поля)

v csWriterows (строки)

Вывод:

Примечание: Для получения дополнительной информации см. Написание файлов CSV на Python.

Сохранение файла JSON в Python

Полная форма JSON — это нотация объектов JavaScript. Это означает, что файл сценария (исполняемый), состоящий из текста на языке программирования, используется для хранения и передачи данных. Python поддерживает JSON через встроенный пакет под названием json .Текст в JSON создается с помощью строки в кавычках, которая содержит значение в сопоставлении «ключ-значение» в пределах {} .

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

импорт json

dict1 = {

"emp1" "имя : «Лиза» ,

«обозначение» : «программист» ,

«возраст» : «34 10 ,

"зарплата" : "54000"

},

"emp2" : {

"название: «Элис» ,

«обозначение» : «Стажер» ,

«возраст» : «24» ,

«зарплата» : «40000»

}

out_file = открыть ( "myfile.json " , " w " )

json.dump (dict1, out_file, indent = 6 )

out ()

Выход:

Примечание: Для получения дополнительной информации см. Работа с данными JSON в Python.

Внимание, компьютерщик! Укрепите свои основы с курсом Python Programming Foundation и изучите основы.

Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS .

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

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

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

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

Режимы доступа к файлам

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

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

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

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

 File_object = open (r "File_Name", "Access_Mode")

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

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

02 открыть файл = (r "D: \ Text \ MyFile2.txt " , " w + " )

Здесь файл1 создается как объект для MyFile1, а файл2 как объект для MyFile2

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

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

File_object.close ()

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

file1.close ()

Запись в файл

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

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

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

Есть три способа чтения данных из текстового файла.

read (): Возвращает прочитанные байты в виде строки. Читает n байтов, если n не указано, читает весь файл.
File_object.read ([n])
readline (): Считывает строку файла и возвращает в виде строки. Для указанного n считывает не более n байтов.Однако не читает более одной строки, даже если n превышает длину строки.
File_object.readline ([n])
readlines (): Считывает все строки и возвращает их как каждую строку как строковый элемент в списке.
File_object.readlines ()

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

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

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

file1.запись ( "Hello \ n" )

file1.writelines (L)

file1.close ()

file1 = open ( «myfile.txt» , «r +» )

print «Вывод функции чтения»

print file1.read ()

9000 печать

файл1.seek ( 0 )

print «Вывод функции Readline»

print file1.readline ()

print

02 file1.seek ( 0 )

print «Вывод функции чтения (9):»

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

print

file1.seek ( 0 )

print Readline ( ") Функция вывода это "

print file1.readline ( 9 )

file1.seek ( 0 )

print функция" "

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

print

file1.close ()

Вывод:

Вывод функции чтения
Привет
Это Дели
Это париж
Это лондон


Вывод функции Readline:
Привет


Вывод функции Read (9):
Привет
Чт

Вывод функции Readline (9):
Привет

Вывод функции Readlines:
['Привет \ n', 'Это Дели \ n', 'Это Париж \ n', 'Это Лондон \ n']

Добавление к файлу

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

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

file1.close ()

file1 = open ( "myfile.txt" , " a " )

файл1.напишите ( "Сегодня \ n" )

file1.close ()

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

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

print file1.readlines ()

print

file1.close () 0

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

file1.write ( " Tomorrow \ n " )

file1.close ()

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

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

print file1.readlines ()

печать

файл1.закрыть ()

Выход:

Вывод строк чтения после добавления
['Это Дели \ n', 'Это Париж \ n', 'Это Лондон \ n', 'Сегодня \ n']

Вывод строк чтения после записи
['Завтра \ n']

Связанная статья:
Объекты файлов в Python

Эта статья предоставлена Harshit Agrawal . Если вам нравится GeeksforGeeks, и вы хотите внести свой вклад, вы также можете написать статью, используя свой вклад.geeksforgeeks.org или отправьте свою статью по адресу [email protected]. Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам.

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

Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

Сохранение текста, JSON и CSV в файл в Python

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

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

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

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

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

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

Открыть файл в Python просто:

  my_data_file = open ('data.txt ',' ш ')

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

Вот некоторые из наиболее часто используемых:

r - (режим по умолчанию) открыть файл для чтения
w - открыть файл для записи, перезаписав содержимое, если файл уже существует с данными
x - создает новый файл, сбой, если он существует
a - открыть файл для записи, добавив новые данные в конец содержимого файла, если он уже существует
b - записывать двоичные данные в файлы вместо текстовых данных по умолчанию
+ - разрешить чтение и запись в режиме

Допустим, вы хотите записать в файл, а затем прочитать его, ваш режим должен быть 'w +'.Если вы хотите записать, а затем прочитать из файла, не удаляя предыдущее содержимое, вы будете использовать «a +».

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

В Python закрыть файл стало еще проще:

  my_data_file.close ()

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

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

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

Использование ключевого слова "с"

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

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

  с open ('data.txt', 'w') как my_data_file:
    # TODO: записать данные в файл
# После выхода из вышеуказанного блока кода файл закрывается

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

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

Сохранение текстового файла

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

К счастью, Python делает и это простым:

  с открытым ('do_re_mi.txt ',' w ') как f:
    f.write ('Лань, олень, самка оленя \ n')
    f.write ('Луч, капля золотого солнца \ n')

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

Примечание : обратите внимание на включение символа новой строки, \ n . Он используется для записи в следующую строку файла, в противном случае весь текст будет добавлен как одна строка.

Сохранение нескольких строк одновременно

С помощью функции write () мы можем взять одну строку и поместить ее в файл. Что, если бы мы хотели написать сразу несколько строк?

Мы можем использовать функцию writelines () для помещения данных в последовательность (например, список или кортеж) и в файл:

  с open ('browsers.txt', 'w') как f:
    web_browsers = ['Firefox \ n', 'Chrome \ n', 'Edge \ n']
    f.writelines (веб-браузеры)

Как и раньше, если мы хотим, чтобы данные отображались в новых строках, мы включаем символ новой строки в конец каждой строки.

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

  с open ('browsers.txt', 'w') как f:
    web_browsers = ['Firefox \ n', 'Chrome \ n', 'Edge \ n']
    f.writelines ("% s \ n"% строка для строки в web_browsers)

Примечание : ввод для Writelines () должен быть простой последовательностью строк или байтов - числа, объекты или вложенные последовательности, такие как список в списке, не допускаются.

Если вам интересно узнать больше о списках и кортежах, у нас уже есть статья, посвященная им - Списки против кортежей в Python.

Сохранение файла CSV

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

  импорт CSV

будние дни = ['понедельник', 'вторник', 'среда', 'четверг', 'пятница']
продажи = ['10', '8', '19', '12', '25']

с открытым ('продажи.csv ',' w ') как csv_file:
    csv_writer = csv.writer (csv_file, delimiter = ',')
    csv_writer.writerow (будние дни)
    csv_writer.writerow (продажи)

Сначала нам нужно импортировать библиотеку csv , чтобы получить их вспомогательные функции. Мы открываем файл, как мы привыкли, но вместо записи содержимого в объект csv_file мы создаем новый объект с именем csv_writer .

Этот объект предоставляет нам метод writerow () , который позволяет нам поместить все данные строки в файл за один раз.

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

Сохранение файла JSON

JSON - еще один популярный формат для хранения данных, и, как и в случае с CSV, Python упростил запись данных словаря в файлы JSON:

  импорт json

my_details = {
    'name': 'Джон Доу',
    'возраст': 29
}

с open ('personal.json', 'w') как json_file:
    json.dump (my_details, json_file)

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

Если вы хотите узнать больше об использовании файлов JSON в Python, вы можете больше узнать из этой статьи: Чтение и запись JSON в файл в Python.

Заключение

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

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

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

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

Запись в файл с помощью функции Python print ()

Введение

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

В этой статье мы рассмотрим множество способов записи в файл с помощью функции print () .

Перенаправление вывода скрипта Python в терминал

Быстрый и грязный способ перенаправить вывод скрипта Python - прямо из командной строки во время выполнения скрипта.

Например, если у нас есть файл Python с именем hello.py со следующим содержимым:

  print ("Hallo") # Умышленно на немецком языке

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

  $ python3 привет.py> output.txt

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

  Привет

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

Перенаправление стандартного выходного потока

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

Во всех системах UNIX есть три основных канала - стандартный входной канал ( stdin ), стандартный выходной канал ( stdout ) и стандартный канал ошибок ( stderr ).

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

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

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

Давайте посмотрим на пример, в котором мы меняем stdout на файл:

  импортная система

print ('Это сообщение будет отображаться на экране.')

original_stdout = sys.stdout # Сохранить ссылку на исходный стандартный вывод

с open ('filename.txt', 'w') как f:
    sys.stdout = f # Измените стандартный вывод на созданный нами файл.
    print ('Это сообщение будет записано в файл.')
    sys.stdout = original_stdout # Сброс стандартного вывода на исходное значение

Функция print () принимает указанный строковый аргумент, добавляет в конец символ новой строки и вызывает стандартный вывод .write () , чтобы записать его в стандартный вывод.

В приведенном выше примере мы сначала печатаем строку текста, как мы привыкли, которая будет отображаться в консоли при запуске файла. Затем мы переназначили stdout нашему пользовательскому объекту файла - f . Поскольку файловый объект имеет совершенно допустимый метод write () , наше напечатанное значение без проблем записывается в файл.

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

Сохраним код в новый файл, printToFile.py . А затем выполним:

  $ python3 printToFile.py

В Терминале мы увидим следующий вывод:

  Это сообщение будет отображаться на экране.

И сценарий создаст новый файл с именем filename.txt со следующим содержимым:

  Это сообщение будет записано в файл.

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

Перенаправление стандартного потока ошибок

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

Создайте файл с именем printToStderr.py и добавьте следующий код:

  импортная система

print ('Это сообщение будет отображаться через стандартный вывод.')

original_stdout = sys.stdout # Сохранить ссылку на исходный стандартный вывод

sys.stdout = sys.stderr # Перенаправить стандартный вывод на стандартную ошибку.
print ('Это сообщение будет отображаться при стандартной ошибке.')

sys.stdout = original_stdout # Сброс стандартного вывода на исходное значение

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

Запустим этот файл:

  $ python3 printToStderr.py

Наш вывод покажет:

  Это сообщение будет отображаться через стандартный вывод.
Это сообщение будет отображаться через стандартную ошибку.

Хотя нам это может показаться обычным выводом, для компьютера он отображается через разные конвейеры.

Печать с использованием параметра "файл"

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

Например, если бы мы хотели печатать прямо в файл, не изменяя stdout всего скрипта, мы бы написали:

  импортная система

print ('Это сообщение будет отображаться на экране.')

с open ('filename.txt', 'w') как f:
    print ('Это сообщение будет записано в файл.', file = f)

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

Примечание: Хотя имя параметра - файл , помните, что он работает с любым файловым объектом. Например, если вы хотите печатать на stderr , вы должны изменить оператор print () на:

  print ('Это сообщение будет записано в stderr.', файл = sys.stderr)

Заключение

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

Об авторе

Эта статья была написана Якобом Стопаком, разработчиком программного обеспечения и консультантом, страстно желающим помочь другим улучшить свою жизнь с помощью кода.Джейкоб является автором Руководства по основам кодирования для разработчиков, вводной книги, в которой рассматриваются основные концепции и инструменты кодирования. Он содержит главы по базовой компьютерной архитектуре, Интернету, командной строке, HTML, CSS, JavaScript, Python, Java, базам данных / SQL, Git и многому другому.

python 2.x - как перенаправить вывод печати в файл?

Возможно, вам не понравится этот ответ, но я думаю, что он ПРАВИЛЬНЫЙ. Не меняйте место назначения stdout, если это не является абсолютно необходимым (возможно, вы используете библиотеку, которая выводит только на stdout ???, здесь явно не тот случай).

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

Вот пример:

  out_lines = []
для bamfile в bamfiles:
    имя_файла = bamfile.split ('/') [- 1]
    out_lines.append ('Имя файла:% s'% имя файла)
    samtoolsin = subprocess.Popen (["/ share / bin / samtools / samtools", "просмотр", bamfile],
                                  stdout = subprocess.PIPE, bufsize = 1)
    linelist = samtoolsin.stdout.readlines ()
    print 'Readlines завершен!'
    out_lines.extend (список строк)
    out_lines.append ('\ п')

А затем, когда вы закончите собирать свои «строки данных» по одной строке на элемент списка, вы можете объединить их с '\ n' символами, чтобы все это можно было выводить; возможно, даже заключите ваш выходной оператор в блок с для дополнительной безопасности (автоматически закроет ваш выходной дескриптор, даже если что-то пойдет не так):

  out_string = '\ n'.присоединиться (out_lines)
out_filename = 'myfile.txt'
с open (out_filename, 'w') в качестве наряда:
    outf.write (out_string)
print "УРА МОЙ STDOUT НЕ ПОДДЕРЖИВАЕТСЯ !!!"

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

  out_filename = 'myfile.txt'
Outf = open (имя_файла, 'ш')
для bamfile в bamfiles:
    filename = bamfile.split ('/') [- 1]
    outf.write ('Имя файла:% s'% имя_файла)
    samtoolsin = подпроцесс.Popen (["/ share / bin / samtools / samtools", "просмотр", bamfile],
                                  stdout = subprocess.PIPE, bufsize = 1)
    mydata = samtoolsin.stdout.read ()
    outf.write (mydata)
Outf.close ()

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

Процесс записи в файл очень похож на процесс чтения из файла (который рассматривается в отдельном уроке), поскольку оба требуют открытия файлового объекта для доступа.Разница заключается во втором аргументе с по open () , в котором передается строка "w" - сокращение от write .

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

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

  newfile.write ("привет, мир")
newfile.write ("прощай, мир")
новый файл.написать ("вокка вокка")
newfile.close ()

Запись двоичного файла

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

  newfile = open ("somebinaryfile.zip", "wb")

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

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

  >>> myfile = open ("blaskdfjsadklfjdfsadflkj", "r")
FileNotFoundError: [Errno 2] Нет такого файла или каталога: 'blaskdfjsadklfjdfsadflkj'

Что произойдет, если вы попытаетесь открыть файл в режиме записи с таким же бессмысленным именем?

  >>> myfile = open ("blaskdfjsadklfjdfsadflkj", "w")

Ничего, по крайней мере, по ошибке.Вместо этого будет создан файл с именем blaskdfjsadklfjdfsadflkj везде, где выполняется ваш код. Если вы запускали его из каталога ~ / Desktop , например:

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

Вот почему в каждом из назначений я предлагаю вам создать новый подкаталог tempdata и спрятать в нем все, чтобы уменьшить вероятность того, что вы в конечном итоге перезапишете существующие файлы в других файловых каталогах. Но вы все равно должны быть осторожны - то есть уделите несколько секунд и подумайте о том, что вы делаете, прежде чем нажимать Enter - всякий раз, когда вы передаете "w" или "wb" в функцию open () .

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

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

Рассмотрим следующий код, который загружает HTML-содержимое текущей домашней страницы New York Times в переменную с именем nyttext :

  запросов на импорт
resp = запросы.получить ("https://www.nytimes.com")
nyttext = соответственно текст

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

  из os.path import join
запросы на импорт
resp = запросы.получить ("https://www.nytimes.com")
nyttext = соответственно текст
outfname = join ("tempdata", "nytimes.com.html")
Outfile = open (имя снаряжения, "ш")
Outfile.write (nyttext)
Outfile.close ()

Стратегии предотвращения перезаписи файлов

Конечно, если мы повторно запустим этот сценарий в следующий час, день или даже в следующую секунду, все, что было на "tempdata / nytimes.com.html" , будет перезаписано.

Использовать текущее время в имени файла

Одна из стратегий - включить текущую отметку времени в имя файла, которое нужно сохранить.Здесь я создаю подкаталог с именем nytimes.com , и каждому файлу в нем присваивается имя вроде 1453688120.431147.html , причем числа являются результатом функции time.time () , которая возвращает значение " текущее время в секундах с начала ":

  из os.path import join
из os import makedirs
запросы на импорт
время импорта
# Настроить место для хранения
STORAGE_DIR = присоединиться ("временные данные", "nytimes.com")
македирс (STORAGE_DIR, exist_ok = True)
# Скачать страницу
resp = запросы.получить ("https://www.nytimes.com")
# Настроить новый файл
current_time = str (время.время ())
print ("Время в секундах с начала эпохи:", current_time)
outfname = join (STORAGE_DIR, current_time + '.html')
Outfile = open (имя снаряжения, "ш")
Outfile.write (соответственно текст)
Outfile.close ()

Если вы сохранили этот код в скрипте с именем nytdownload.py , а затем повторно запускали его через интерпретатор командной строки:

  $ python nytdownload.py
Время в секундах с начала эпохи: 1453689209.676369
$ python nytdownload.py
Время в секундах с начала эпохи: 1453689210,85706
$ python nytdownload.py
Время в секундах с начала эпохи: 1453689212.452021
$ python nytdownload.py
Время в секундах с начала эпохи: 1453689213,67095.

У вас будет подкаталог tempdata / nytimes.com , полный файлов:

 .
├── nytdownload.py
└── временные данные
    └── nytimes.com
        ├── 1453689209.676369.html
        ├── 1453689210.85706.html
        ├── 1453689212.452021.html
        └── 1453689213.67095.html

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

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

Мы можем использовать метод exists () из модуля os.path , который возвращает True или False , если путь, переданный в него, в настоящее время существует:

  от os.соединение импорта пути
из os.path существует импорт
запросы на импорт
SHAKE_URL = "http://stash.compciv.org/scrapespeare/matty.shakespeare.tar.gz"
SHAKE_LOCAL_PATH = присоединиться ("временные данные", "shakespeare.tar.gz")
если существует (SHAKE_LOCAL_PATH):
    print ("Пропуск загрузки;", SHAKE_LOCAL_PATH, 'уже существует')
еще:
    print («Скачивание», SHAKE_URL)
    resp = requests.get (SHAKE_URL)
    outfile = open (SHAKE_LOCAL_PATH, 'wb')
    # помните, что у объектов Requests Response есть `content`
    # атрибут при работе с содержимым двоичных файлов
    Outfile.написать (соответственно содержание)
    print ("Файл сохранен в:", SHAKE_LOCAL_PATH)
    Outfile.close ()

Сохраните этот код в файл, например shakeydownload.py и запустите его из командной строки. Предполагая, что у вас нет ничего по пути tempdata / shakespeare.tar.gz и загрузка успешно завершена, вы должны увидеть этот результат через несколько секунд или сколько времени потребуется вашей коллекции в Интернете, чтобы загрузить все работы Шекспира. :

  $ python shakeydownload.ру
Скачивание http://stash.compciv.org/scrapespeare/matty.shakespeare.tar.gz
Сохраненный файл: tempdata / shakespeare.tar.gz

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

  $ python shakeydownload.py
Пропуск загрузки; tempdata / shakespeare.tar.gz уже существует
$ python shakeydownload.py
Пропуск загрузки; tempdata / shakespeare.tar.gz уже существует

Если удалить (или переименовать) tempdata / shakespeare.

Python сохранить в файл: Работа с файлами в Python

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

Как читать файлы

Как читать файл по частям

Как читать бинарные (двоичные) файлы

Пишем в файлах в Python

Использование оператора «with»

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

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

Python скрипт должен сохранить вывод в текстовый файл

3 ответа

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

Сохранение, загрузка и повторный вызов работы в окне Python—Справка

Сохранение работы

Загрузка в окно Python

Повторный вызов кода Python

Работа с файлами в python. Чтение и запись в файл ~ PythonRu

Файлы Python

Текстовые файлы

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

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

Метод open()

Пример

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

Метод close()

Инструкция with

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

Функция read()

Функция readline()

Функция write()

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

Функция rename()

Текущая позиция в файлах Python

Методы файла в Python

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

Создаем новый файл в Python

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

Заменяем данные из определенной строки файла

Копирование файлов в Python

python — Как сохранить список в файл и прочитать его как тип списка?

7 ответов

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

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

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

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

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

Поиск строки

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

Как создавать, открывать, добавлять, читать, писать

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

Как создать текстовый файл в Python

Как добавить в файл в Python

Как читать файлы в Python

Как читать файл построчно в Python

Файловые режимы в Python

Сохранение текста, JSON и CSV в файл в Python

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

Сохранение текстового файла в Python

с

Сохранение CSV-файла в Python

Сохранение файла JSON в Python

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

Сохранение текста, JSON и CSV в файл в Python

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

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

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

Использование ключевого слова "с"

Сохранение текстового файла

Сохранение нескольких строк одновременно

Сохранение файла CSV

Сохранение файла JSON

Заключение

Запись в файл с помощью функции Python print ()

Введение

Перенаправление вывода скрипта Python в терминал

Перенаправление стандартного выходного потока

Перенаправление стандартного потока ошибок

Печать с использованием параметра "файл"

Заключение

Об авторе

`Добавить комментарий Отменить ответ`