Python запись в файл: Работа с файлами в Python

Содержание

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

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

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

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


  • file – это путь к
    файлу вместе с его именем;

  • mode – режим доступа
    к файлу;

  • encoding
    – кодировка
    файла.

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

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

«my_file.txt»

или

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

или так:

«d:/app/my_file.txt»

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

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

«images/img.txt»

или так:

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

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

«../out.txt»

«d:/out.txt»

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

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

«../parent/prt.dat»

«d:/ parent/prt.dat»

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

file = open("myfile.txt")

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

file = open("myfile2.txt")

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

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

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

mode = «r»

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

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

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










Название

Описание

‘r’

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

‘w’

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

‘x’

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

‘a’

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

Дополнения

‘b’

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

‘t’

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

‘+’

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

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


  • ‘rt’ – чтение в
    текстовом режиме;

  • ‘wb’ – запись в
    бинарном режиме;

  • ‘a+’ – дозапись
    или чтение данных из файла.

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

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

file = open("myfile.txt")

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

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

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

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

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

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

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

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

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

seek(offset[, from_what])

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

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

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

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

pos = file.tell()
print( pos )

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

s = file.readline()
print( s )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

finally:
    print(file.closed)

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

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

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

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

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

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

file.write("Hello World!")

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

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

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

w, wt, wb,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

d = {«house»:
«дом», «car»: «машина»,


    
«tree»:
«дерево», «road»: «дорога»,


     «river»:
«река»}

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

Python запись результатов в файл

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

Я думал, что это было сделано с file.write()

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

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

import adodbapi

# Connect to the SQL DB    
conn = adodbapi.connect("Provider=SQLOLEDB; SERVER=xx.x.xx.x; Initial Catalog=master_db;User Id=user; Password=pass; ")
curs = conn.cursor()

# Execute SQL procedure things_referencing"    
curs.execute('util.things_procedure', )
results = curs.fetchall()

for row in results:
    print row

f = open('test.txt', 'w')
s = str(row)
f.write(s)
f.close()

conn.close()

python

Поделиться

Источник


user1304228    

20 апреля 2012 в 17:31

2 ответа


  • запись отсортированных результатов в файл

    У меня есть простая функция, которая сортирует словарь: data = inputfile.readlines() lineData = sorted(data, key=len, reverse=True)[:3] Печать выходных данных: print sorted(data, key=len, reverse=True)[:3] генерирует ожидаемый результат, однако запись в файл: outputfile.writelines sorted(data,…

  • запись вывода Python shell в файл

    Очень простой вопрос. Я использую IDLE Python shell для запуска своих скриптов Python. Я использую следующий тип структуры import sys sys.argv = [»,’fileinp’] execfile(‘mypythonscript.py’) Есть ли простой способ вывода результатов в файл? Что-то вроде execfile(‘mypythonscript.py’) >…



10

Каждый «row» в кортеже «results» является кортежем записей. Как вы хотите отформатировать эти данные, зависит от вас, но на самом базовом уровне вы можете преобразовать их в строку с str(row)

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

http://docs.python.org/tutorial/inputoutput.html

Обновление

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

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

with open('test.txt', 'w') as f:
    for row in results:
        print row
        f.write("%s\n" % str(row))

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

Поделиться


jdi    

20 апреля 2012 в 17:39



1

это действительно сделано с file.write, но сначала вы должны открыть файл. Таким образом, вы бы изменили for loop примерно так, как показано ниже

f = open('/path/to/file', 'w')
for row in results:
    f.write(row)
f.close()

Поделиться


ntlarson    

20 апреля 2012 в 17:40


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

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

Сегодня мне удалось запустить свой первый в истории сценарий Python. Я новичок, на машине Windows 7. Когда я запускаю python.exe и ввожу следующее (Python установлен в C:/Python27) import os…

Запись двоичного буфера в файл в python

У меня есть какой-то код python, который: Берет BLOB из базы данных, которая сжата. Вызывает процедуру распаковки в C, которая распаковывает данные. Записывает несжатые данные в файл. Он использует…

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

Я создал пакет, который будет использовать windows FINDSTR для поиска моего выборочного ввода. Я пытаюсь записать результаты поиска в текстовый файл под названием results.txt Так что у меня есть…

запись отсортированных результатов в файл

У меня есть простая функция, которая сортирует словарь: data = inputfile.readlines() lineData = sorted(data, key=len, reverse=True)[:3] Печать выходных данных: print sorted(data, key=len,…

запись вывода Python shell в файл

Очень простой вопрос. Я использую IDLE Python shell для запуска своих скриптов Python. Я использую следующий тип структуры import sys sys.argv = [»,’fileinp’] execfile(‘mypythonscript.py’) Есть ли…

запись результатов запроса sql в файл в mysql

Я пытаюсь записать результаты запроса в файл с помощью mysql. Я видел некоторую информацию о конструкции outfile в нескольких местах, но кажется, что это только записывает файл на машину, на которой…

Python скрипт для поиска и экспорта результатов в файл .csv

Я пытаюсь сделать следующее в Python, также используя некоторые сценарии bash. Если только в Python нет более легкого пути. У меня есть файл журнала с данными, которые выглядят следующим образом:…

Запись результатов теста Python Selenium в файл

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

python неблокирующая запись csv файл

Я пишу какой-то код python, чтобы сделать некоторые вычисления и записать результат в файл. Вот мой текущий код: for name, group in data.groupby(‘Date’): df = lot_of_numpy_calculations(group) with…

Python 3: запись нескольких словарей в файл CSV постепенно

Я проверил тему: запись нескольких словарей Python в файл csv, но я думаю, что это еще не ответ на мой вопрос. У меня есть несколько словарей, таких как: {day:1, temperature: 30} {day:2,…

Построчные чтение и запись | Python: Основы текстового ввода-вывода

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

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

>>> f = open("foo.txt", "w")
>>> f.writelines(["cat\n", "dog\n"])
>>> f.close()
>>> f = open("foo.txt", "r")
>>> print(f.read())
cat
dog

>>> f.close()

Как вы видите, все строчки записались в нужном порядке. Такой вариант записи предпочтителен, когда нужно записать большой объем текста, который вы получаете и обрабатываете строчка-за-строчкой. Можно предварительно накопить весь текст в одну большую строку, однако для этого может потребоваться большой объём памяти. Гораздо лучше записывать строчки по мере готовности и writelines для этого подходит идеально!

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

Файл построчно можно не только писать, но и читать:

>>> f = open("foo.txt")
>>> f.readline()
'cat\n'
>>> f.readline()
'dog\n'
>>> f.readline()
''
>>> f.close()

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

Заметьте, строчки текста содержат и сами символы перевода строки.

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

>>> f = open("foo.txt")
>>> for l in f:
...     print(l)
...
cat

dog

>>> f.close()

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

Подумайте, почему напечатались лишние пустые строчки.

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

Ленивость позволяет, в частности, не дочитать файл:

>>> f = open("foo.txt")
>>> for l in f:
...     print(l)
...     break
...
cat

>>> print(f.read())
dog

>>> f.close()

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

Потоковая обработка больших файлов

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

input_file = open("input.txt", "r")
output_file = open("output.txt", "w")
for i, line in enumerate(input_file, 1):
    output_file.write("{}) {}".format(i, line))
input_file.close()
output_file.close()

Изучаем 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» , подготовленная редакцией проекта.

3 способа записи списка в файл на Python

Краткое описание: В этой краткой статье демонстрируются три способа записи списка в файл на языке сценариев Python.

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

 

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

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

 

Метод 1: Запись списка в файл строка за строкой в ​​Python, используя print

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

Вот пример программы на Python для вашей справки:

MyList = ["Самара", "Сочи", "Мурманск", "Анапа"] 
MyFile = open ('output.txt', 'w')
for element in MyList:
    print >>MyFile, element
MyFile.close()

 

Файл output.txt открывается в режиме записи. Цикл for в python повторяется для каждого элемента в списке. Команды печати записывают элемент в открытый файл.

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

Самара
Сочи
Мурманск
Анапа

 

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

В примерах файл был открыт в режиме записи с опцией ‘w’. Все предыдущее содержимое файла в этом режиме будет перезаписано.

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

 

Способ 2: записать список в файл, используя функцию записи в Python

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

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

Вот пример программы на Python:

MyList = ["Самара", "Сочи", "Мурманск", "Анапа"] 
MyFile=open('output.txt', 'w')
for element in MyList:
     MyFile.write(element)
     MyFile.write('\n')
MyFile.close()

 

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

 

Способ 3: записать все строки в файл одновременно, используя функцию writelines()

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

Вот простая программа:

MyList = ["Самара", "Сочи", "Мурманск", "Анапа"] 

MyFile = open ('output.txt', 'w') 
MyFile.writelines (MyList) 
MyFile.close ()

 

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

СамараСочиПарисАнапа

 

Это не самый красивый вывод. Но это точное содержание списка.

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

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

Вот пример программы для этого:

MyList = ["Самара", "Сочи", "Мурманск", "Анапа"] 

MyFile = open ('output.txt', 'w') 
MyList = map (lambda x: x + '\ n', MyList) 
MyFile.writelines (MyList) 
MyFile.close ()

 

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

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Запись файлов — Документация 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. Часть 11. Работа с файлами

Этот выпуск – о работе с файлами в Python. Научимся открывать, создавать и изменять файлы с текстовой и табличной информацией. Тетрадка Jupyter Notebook этого урока доступна на нашем GitHub. 

Видео: Глеб Лиманский

Открываем файл и читаем из него данные

Самый простой формат, в котором могут храниться текстовые данные, – txt. Для примера я создала на компьютере файл с текстом Конституции, в которую для тренировки мы внесем собственные поправки, как это сделал президент России в 2020 году. Прежде, чем работать с файлом, надо его открыть. Это делается с помощью встроенной функции open. В скобках мы сперва прописываем путь к файлу, а затем режим, в котором хотим открыть файл – в данном случае мы открываем файл для чтения, за это отвечает режим «r» (от слова read).

Открыли файл, теперь надо прочитать информацию из него. Для этого есть несколько способов. Самый простой – это вывести всю информацию из файла целиком. За это отвечает операция read.

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

Распечатать информацию построчно можно с помощью цикла и без использования read.

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

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

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

Чтобы получить список из строк, используют операцию readlines. 

Внутри всех этих операций можно указывать количество символов, которые мы хотим прочитать из файла. Например, read(11) прочитает первые 11 символов. 

Создаем файл и записываем в него данные

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

Еще один режим, который можно указать – «a» (от слова append) – это открытие на добавление данных. В таком случае данные добавятся в конец существующего файла. Давайте добавим в текст Конституции еще одну статью.

С помощью операции write мы записали в файл информацию из строки. Чтобы записать информацию из какой-либо последовательности, например, списка, используют writelines. Давайте запишем в Конституцию еще несколько статей.

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

Работаем с csv-файлами

Открытые данные, с которыми работают журналисты, часто представлены в формате csv – от слов comma separated values, то есть значения, разделенные запятыми. Это текстовый формат для представления табличных данных. Для примера зайдем на сайт Минобрнауки и скачаем данные о численности студентов по направлениям подготовки. Для упрощенной работы с файлами csv в Питоне есть специальный встроенный модуль csv. Давайте импортируем его. 

Для чтения используется функция reader. Откроем файл, создадим объект reader и попросим распечатать содержимое файла построчно.

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

Из результата мы копируем полученную кодировку и вставляем ее в код в параметре encoding. 

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

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

C помощью операции fieldnames мы сможем узнать названия столбцов в наших данных. 

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

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

И наконец, записываем старые данные из словаря в новый файл с помощью writerows.

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

Выход:

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


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

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

Синтаксис:

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

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

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

file1.write ( " Hello \ n " )

file1.writelines ( L)

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

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

Выход:

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

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

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

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

python — Правильный способ записи строки в файл?

Если вы пишете много данных и скорость вызывает беспокойство, вам, вероятно, следует использовать f.write (...) . Я провел быстрое сравнение скорости, и он был значительно быстрее, чем print (..., file = f) при выполнении большого количества операций записи.

  время импорта

старт = старт = время.время()
с open ("test.txt", 'w') как f:
    для i в диапазоне (10000000):
        # print ('Это тест скорости', file = f)
        # f.write ('Это тест скорости \ n')
конец = время.время ()
печать (конец - начало)
  

В среднем запись завершилась за 2,45 секунды на моей машине, тогда как печать заняла примерно в 4 раза больше времени (9,76 секунды). При этом в большинстве реальных сценариев это не будет проблемой.

Если вы выберете print (..., file = f) , вы, вероятно, обнаружите, что время от времени хотите подавлять новую строку или заменять ее чем-то другим.Это можно сделать, установив необязательный параметр end , например;

  с открытым ("тест", 'w') как f:
    print ('Foo1,', файл = f, конец = '')
    print ('Foo2,', файл = f, конец = '')
    print ('Foo3', файл = f)
  

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

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

  начало = начало = время.время ()
long_line = 'Это тест скорости' * 100
с open ("test.txt", 'w') как f:
    для i в диапазоне (1000000):
        # print (long_line, file = f)
        # f.write (long_line + '\ n')
конец = время.время ()

print (конец - начало, "с")
  

Разница в производительности теперь становится гораздо менее заметной, среднее время равно 2.20 с для напишите и 3,10 с для напишите . Если вам нужно объединить кучу строк, чтобы получить эту длинную строку, производительность пострадает, поэтому варианты использования, когда print будет более эффективным, немного редки.

python — как перенаправить вывод печати в файл?

Возможно, вам не понравится этот ответ, но я думаю, что он ПРАВИЛЬНЫЙ. Не меняйте место назначения 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 ()
  

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

Обзор

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

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

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

Рекомендуемый курс обучения Python

Курс: Python 3 для начинающих

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

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

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

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

Типы файлов

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

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

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

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

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

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

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

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

В Python файлы читаются с использованием метода open () . Это один из встроенных методов Python, предназначенный для открытия файлов.

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

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

На моем компьютере есть папка PythonForBeginners. В этой папке три файла. Один из них — это текстовый файл с именем emily_dickinson.txt, а два других — файлы Python: read.py и write.py.

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

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

Ни один из всех Пурпурных Войск
Кто сегодня взял Флаг
Может сказать определение
Так далеко от Победы

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

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

Для написания кода можно использовать любой текстовый редактор. Я использую редактор кода Atom, который я предпочитаю для работы с Python.

На этом снимке экрана показана моя установка в Atom.

  # read.py
# загрузка файла с помощью open ()
myfile = open («emily_dickinson.txt»)

# чтение каждой строки файла и печать в консоль
для строки в myfile:
print (line)  

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

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

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

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

 > python read.py  

Запуск файла Python в командной строке Windows.

Данные, предоставляемые методом open () , обычно хранятся в новой переменной. В этом примере содержимое стихотворения хранится в переменной «myfile».

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

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

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

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

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

Добавьте следующий код в write.py. Мы скажем Python найти файл с именем «sample.txt» и перезаписать его содержимое новым сообщением.

  # открыть файл в режиме записи
myfile = open («sample.txt», ’w’)

myfile.write («Привет от Python!»)  

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

Если файл не существует, Python создаст новый файл. В этом случае при запуске программы будет создан новый файл с именем «sample.txt».

Запустите программу с помощью командной строки:

 > python write.py  

Python также может записывать несколько строк в файл. Самый простой способ сделать это — использовать метод Writelines () .

  # открыть файл в режиме записи
myfile = open («sample.txt», ’w’)

myfile.writelines («Hello World!», «Мы изучаем Python!»)

# закрыть файл
мой файл.close ()  

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

  # открыть файл в режиме записи
myfile = open ("poem.txt", 'ш')

line1 = "Розы красные. \ n"
line2 = "Фиалки синие. \ n"
line3 = "Python великолепен. \ n"
line4 = "И ты тоже. \ n"

myfile.write (line1 + line2 + line3 + line4)  

Использование конкатенации строк позволяет Python сохранять текстовые данные различными способами.

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

Режимы открытия файлов

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

  • ‘r’ — Режим чтения: это режим по умолчанию для open () . Файл открывается, и указатель помещается в начало содержимого файла.
  • ‘w’ — режим записи: при использовании этого режима любое существующее содержимое файла будет перезаписано.Если данный файл не существует, будет создан новый.
  • ‘r +’ — режим чтения / записи: используйте этот режим, если вам нужно одновременно читать и записывать в файл.
  • ‘a’ — Режим добавления: в этом режиме пользователь может добавлять данные, не перезаписывая уже существующие данные в файле.
  • ‘a +’ — режим добавления и чтения: в этом режиме вы можете читать и добавлять данные без перезаписи исходного файла.
  • ‘x’ — Эксклюзивный режим создания: этот режим предназначен исключительно для создания новых файлов.Используйте этот режим, если заранее знаете, что файл для записи не существует.

Примечание. В этих примерах предполагается, что пользователь работает с типами текстовых файлов. Если предполагается чтение или запись в файл двоичного типа, методу open () необходимо передать дополнительный аргумент: символ «b».

  # двоичным файлам нужен специальный аргумент: ‘b’
binary_file = open («song_data.mp3», ’rb’)
song_data = двоичный_файл.read ()

# закрыть файл
binary_file.close ()  

Закрытие файлов с помощью Python

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

Закройте файл с помощью метода close () .

  # открыть файл
myfile = open («poem.txt»)
# массив для хранения содержимого файла
lines = []
Для строки в myfile:
lines.append (строка)

# закрыть файл
myfile.close ()

Для линии залогового права:
print (line)  

Открытие других типов файлов

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

Прежде чем Python сможет открыть файл изображения, необходимо установить библиотеку Pillow (Python Imaging Library). Этот модуль проще всего установить с помощью pip.

  pip install Pillow  

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

  Из изображения импорта PIL

# скажем Pillow открыть файл изображения
img = Изображение.open («your_image_file.jpg»)
img.show ()
img.close ()  

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

С помощью оператора

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

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

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

    с open («имя файла») как файл:    

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

    с открытым («poem.txt») как файл:  
   data = file.read ()  
   что-то делать с данными    

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

   w  ith open («poem.txt») как f:  
   для линейного входа f:  
   строка печати,    

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

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

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

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

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

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

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

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

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

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

Заключение

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

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

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

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

Дополнительная информация

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

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

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

Курс: Python 3 для начинающих

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

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

Если вас интересует запись текста в файл на Python, вероятно, есть много способов сделать это. Вот три способа записать текст в выходной файл в Python. Первым шагом при записи в файл является создание файлового объекта с помощью встроенной команды Python «open». Чтобы создать и записать в новый файл, используйте опцию «открыть» с «w». Опция «w» удалит любой предыдущий существующий файл и создаст новый файл для записи.

# открыть (новый) файл для записи
outF = open ("myOutFile.txt", "w")
 

Если вы хотите добавить к существующему файлу, используйте оператор open с опцией «a». В режиме добавления Python создаст файл, если он не существует.

# открыть файл для добавления
outF = open ("myOutFile.txt", "а")
 

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

textList = ["Один", "Два", "Три", "Четыре", "Пять"]
 

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

Запись в файл по одной строке за раз с использованием функции write ()

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

outF = open ("myOutFile.txt", "w")
для строки в textList:
  # записываем строку в выходной файл
  outF.написать (строка)
  outF.write ("\ п")
outF.close ()
 

Обратите внимание, что элементы в «textList» не имеют символа новой строки «\ n». Поэтому мы добавили это при записи в файл. В противном случае все пять элементов будут в одной строке выходного файла. Также обратите внимание на outF.close () в конце. close () закрывает доступ к файлу. После завершения работы с файлом рекомендуется использовать метод close () для закрытия файла.

Запись в файл по одной строке за раз с помощью функции print

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

outF = open ("myOutFile.txt", "w")
для строки в textList:
  печать >> outF, строка
outF.close ()
 

writelines (): запись всех строк в файл за один раз в Python

python Writelines для записи всех строк

Python также имеет метод, который может записывать все строки одновременно в файл. Метод Python «writelines () »принимает список строк в качестве входных данных и записывает в объект файла, который открыт с доступом на запись / добавление.Например, чтобы написать наш список всех строк «all_lines», используя «Writelines ().

outF = open ("myOutFile.txt", "w")
outF.writelines (all_lines)
outF.close ()
 

Мы также можем облегчить себе жизнь, не написав оператор file.close (), используя оператор with для записи в файл. Например,

с open (out_filename, 'w') как out_file:
     ..
     ..
     .. parsed_line
     out_file.write (parsed_line)
 

Если вас интересует чтение из текстового файла, отметьте «Три способа чтения текстового файла построчно в python».

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

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

В этом руководстве вы также узнаете о следующих темах:

  • Объект файла Python
  • Как открыть простой плоский файл, например .csv , json и т. Д. И прочитать данные из файла
  • Запись данных в файл
  • Вы также увидите некоторые атрибуты файлового объекта Python
  • Вы также можете покопаться в модуле ОС Python
  • Вы также узнаете о библиотеке NumPy и о том, как ее можно использовать для импорта наборов данных Image

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

Плоские файлы

и не плоские файлы

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

Источник

Хотя как в плоских, так и в неплоских файлах, данные обычно представлены в виде табличных строк и столбцов.

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

XML — это пример не плоского файла .

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

  • Файлы со значениями, разделенными запятыми (CSV), которые содержат значения данных, разделенные символами , , например:
      ИМЯ, АДРЕС, ЭЛЕКТРОННАЯ ПОЧТА
    ABC, CITY A, [адрес электронной почты защищен]
    LMN, CITY B, [адрес электронной почты защищен]
    PQR, CITY C, [адрес электронной почты защищен]
      
  • Файлы с разделителями, которые содержат значения данных с указанным пользователем разделителем.Это может быть вкладка \ t или символ ( # , и , || ), например:
      ИМЯ || АДРЕС || ЭЛЕКТРОННАЯ ПОЧТА
    ABC || CITY A || [адрес электронной почты защищен]
    LMN || CITY B || [адрес электронной почты защищен]
    PQR || CITY C || [адрес электронной почты защищен]
      

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

Объекты файла Python

Python имеет встроенные функции для создания, чтения, записи и управления доступными файлами.Модуль io является модулем по умолчанию для доступа к файлам, которые можно использовать в готовом виде, даже не импортируя их. Перед тем, как читать, писать или манипулировать файлом, вам необходимо использовать модуль open (filename, access_mode) , который возвращает объект файла под названием «handle». После этого вы можете просто использовать этот дескриптор для чтения или записи в файл. Как и все остальное, файлы в Python также рассматриваются как объект, который имеет свои собственные атрибуты и методы.

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

Как вы уже читали ранее, есть два типа плоских файлов, текстовые и двоичные файлы:

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

  • Поскольку двоичные файлы хранят данные после их преобразования в двоичный язык (нули и единицы), символ EOL отсутствует.Этот тип файла возвращает байты. Этот файл используется при работе с нетекстовыми файлами, такими как изображения, .exe, или .pyc .

Давайте теперь подробно разберемся с файловыми объектами Python вместе с необходимыми примерами.

Открыть ()

Встроенная функция Python open () имеет следующие аргументы:
open (file, mode = 'r', buffering = -1, encoding = None, errors = None, newline = None, closefd = True, opener = None)
Функция open () имеет почти 8 параметров вместе со значениями по умолчанию для каждого аргумента, как показано выше.

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

Давайте разберемся с первым аргументом, т.е. файл .

файл

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

Проще говоря, файл аргумент представляет путь, по которому ваш файл находится в вашей системе.

Если путь находится в текущем рабочем каталоге, вы можете просто указать имя файла. Если нет, то вы должны указать абсолютный путь к файлу, как в следующих примерах:
my_file_handle = open ("mynewtextfile.txt")
Если файл находится в каталоге, отличном от текущего каталога, вы должны указать абсолютный путь с именем файла:

  my_file_handle = open ("D: //test.txt")
my_file_handle.read ()
  
  "Добро пожаловать в учебник DataCamp по чтению и записи файлов на Python!"
  

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

  my_file_handle = open ("папка / test.текст")
my_file_handle.read ()
  
  ------------------------------------------------ ---------------------------

FileNotFoundError Traceback (последний вызов последним)

> в 
----> 1 my_file_handle = open ("папка / test.txt")
      2 my_file_handle.read ()


FileNotFoundError: [Errno 2] Нет такого файла или каталога: 'folder / test.txt'
  
Обработка исключений в файлах

Вы можете поймать исключение с помощью блока try-finally:

  попробовать:
    my_file_handle = open ("папка / test.текст")
кроме IOError:
    print («Файл не найден или путь неверен»)
наконец:
    print ("выход")
  
  Файл не найден или неверный путь
выход
  

Давайте разберемся со вторым аргументом функции open , то есть режимами доступа .

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

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

  • режим только для чтения
  • режим только записи
  • режим добавления
  • в режиме чтения и записи

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

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

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

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

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

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

  • читать ([n])
  • строка чтения ([n])
  • строки чтения ()

Здесь n - количество байтов для чтения.Если на n ничего не передается, считается, что прочитан весь файл.

Создайте файл, как показано ниже:
1-я линия
2-я линия
3-я линия
4-я линия
5-я линия
Давайте разберемся, что делает каждый метод чтения:

  my_file = open ("test1.txt", "r")
печать (my_file.read ())
  
  1-я линия
2-я линия
3-я линия
4-я линия
5-я линия
  

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

  my_file = open ("test1.txt", "r")
печать (my_file.read (3))
  
  1-й
  

readline (n) выводит не более n байта одной строки файла. Он не читает больше одной строки.

  my_file.close ()
my_file = open ("test1.txt", "r")
# Используйте print для печати, иначе строка останется в буфере и будет заменена следующим оператором
печать (my_file.readline ())
# выводит первые два символа следующей строки
печать (my_file.readline (2))
  
  1-я линия

2n
  

Закрытие файлов Python с помощью close ()

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

  my_file.close ()
  

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

  my_file = open ("test1.txt "," r ")
# Используйте print для печати, иначе строка останется в буфере и будет заменена следующим оператором
для строки в my_file:
    печать (строка)
my_file.close ()
  
  1-я линия

2-я линия

3-я линия

4-я линия

5-я линия
  

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

  my_file = open ("test1.txt", "r")
my_file.readlines ()
  
  ['1-я строка \ n', '2-я строка \ n', '3-я строка \ n', '4-я строка \ n', '5-я строка']
  

Запись в файл

Для записи в файл на Python можно использовать три метода:

  • запись (строка) (для текста) или запись (byte_string) (для двоичного кода)
  • телефонные линии (список)

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

Создайте файл блокнота и напишите в нем текст. Обязательно сохраните файл как .txt и сохраните его в рабочем каталоге Python.

  new_file = open ("newfile.txt", mode = "w", encoding = "utf-8")
  
  new_file.write («Запись в новый файл \ n»)
новый файл.write ("Запись в новый файл \ n")
new_file.write ("Запись в новый файл \ n")
new_file.close ()
  
Режим добавления

Теперь давайте запишем в этот файл список с режимом a + :

  fruit = ["Апельсин \ n", "Банан \ n", "Яблоко \ n"]
new_file = open ("newfile.txt", mode = "a +", encoding = "utf-8")
new_file.writelines (фрукты)
для строки в new_file:
    печать (строка)
new_file.close ()
  
Метод поиска

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

  автомобили = ["Audi \ n", "Bentley \ n", "Toyota \ n"]
new_file = open ("newfile.txt", mode = "a +", encoding = "utf-8")
для машины в авто:
    new_file.write (автомобиль)
print ("Сообщите байт, в котором находится курсор файла:", new_file.tell ())
новый_файл.seek (0)
для строки в new_file:
    печать (строка)
  
  Укажите байт, в котором находится курсор файла: 115
Запись в новый файл

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

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

апельсин

Банан

яблоко

Audi

Bentley

Тойота
  

Метод tell () файлового объекта сообщает, в каком байте находится файловый курсор.В поиске (смещение, контрольная_точка) опорными точками являются 0 (начало файла по умолчанию), 1 (текущая позиция файла) и 2 (конец файла). ).

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

  новый_файл.seek (4,0)
печать (новый_файл.readline ())
new_file.close ()
  
  ing в новый файл
  
следующий Метод

Остался только метод next () , так что давайте завершим этот раздел руководства! Здесь вы используете тот же файл, созданный выше, с именем test1.txt .

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

  file = open ("test1.txt", "r")
для индекса в диапазоне (5):
    строка = следующий (файл)
    печать (строка)
file.close ()
  
  1-я линия

2-я линия

3-я линия

4-я линия

5-я линия
  

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

Импорт романа Моби Дика

«Моби Дик» - это роман американского писателя Германа Мелвилла 1851 года. Вы будете работать с файлом moby_dick.txt. Это текстовый файл, содержащий вступительные предложения Моби Дика, одного из великих американских романов! Здесь вы получите опыт открытия текстового файла, печати его содержимого и, наконец, его закрытия.

Вы можете скачать текстовый файл moby dick отсюда / _datasets / moby_dick.txt).

Вы будете делать следующее:

  • Откройте файл moby_dick.txt в режиме только для чтения и сохраните его в файле переменных

  • Распечатать содержимое файла

  • Проверить, закрыт ли файл

  • Закройте файл с помощью метода close ()

  • Еще раз проверить, закрыт ли файл

  # Открыть файл: file
file = open ('moby_dick.txt ',' r ')

# Распечатать
печать (file.read ())
печать ('\ п')
# Проверяем, закрыт ли файл
print ('Файл закрыт ?:', file.closed)

# Закрыть файл
file.close ()
печать ('\ п')
# Проверяем, закрыт ли файл
print ('Файл закрыт ?:', file.closed)
  
  ГЛАВА 1. Ткацкие станки.

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


Файл закрыт ?: False


Файл закрыт ?: Верно
  
Чтение романа Моби Дика с помощью диспетчера контекста

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

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

  с открытым ('moby_dick.txt') как файл:
    печать (file.readline ())
    печать (file.readline ())
    печать (file.readline ())
  
  ГЛАВА 1. Ткацкие станки.



Зовите меня Измаил. Несколько лет назад - неважно, сколько именно - имея
  
Запись в файл JSON

Вы также можете записать свои данные на .json файлов.

Помните: Javascript Object Notation (JSON) стал популярным методом обмена структурированной информацией по сети и обмена информацией между платформами. По сути, это текст с некоторой структурой, и сохранение его как . Json сообщает, как читать структуру; в противном случае это просто текстовый файл. Он хранит данные в виде пар ключ: значение. Структура может быть простой или сложной.

Взгляните на следующий простой JSON для стран и их столиц:

  {
«Алжир»: «Алжир»,
«Андорра»: «Андорра-ла-Велья»,
«Непал»: «Катманду»,
«Нидерланды»: «Амстердам»,
}
  

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

  {
  "цвета": [
    {
      "черный цвет",
      "категория": "оттенок",
      "тип": "первичный",
      "code": {
        "rgba": [255,255,255,1],
        "шестнадцатеричный": "# 000"
      }
    },
    {
      "цвет белый",
      "категория": "значение",
      "code": {
        "rgba": [0,0,0,1],
        "шестнадцатеричный": "#FFF"
      }
    },
    {
      "красный цвет",
      "категория": "оттенок",
      "тип": "первичный",
      "code": {
        "rgba": [255,0,0,1],
        "шестнадцатеричный": "# FF0"
      }
    },
    {
      "цвет синий",
      «категория»: «оттенок»,
      "тип": "первичный",
      "code": {
        "rgba": [0,0,255,1],
        "шестнадцатеричный": "# 00F"
      }
    },
    {
      «цвет»: «желтый»,
      "категория": "оттенок",
      "тип": "первичный",
      "code": {
        "rgba": [255,255,0,1],
        "шестнадцатеричный": "# FF0"
      }
    },
    {
      "цвет": "зеленый",
      «категория»: «оттенок»,
      "тип": "вторичный",
      "code": {
        "rgba": [0,255,0,1],
        "шестнадцатеричный": "# 0F0"
      }
    },
  ]
}
  

Обратите внимание, что файлы JSON также могут содержать разные типы данных в одном объекте!

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

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

  # Импорт модуля json
импортировать json
my_data = ["Чтение и запись файлов на Python", 78546]
json.dumps (my_data)
  
  '["Чтение и запись файлов на python", 78546]'
  

Чтобы записать JSON в файл, вы можете использовать .dump () метод:

  с открытым ("jsonfile.json", "w") как f:
    json.dump (my_data, f)
f.close ()
  

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

Давайте теперь откроем файл JSON , который вы создали с помощью метода dump . Если файл JSON открыт для чтения, вы можете декодировать его с помощью load (file) следующим образом:

  с открытым ("jsonfile.json "," r ") как f:
    jsondata = json.load (е)
    печать (jsondata)
f.close ()
  
  ['Чтение и запись файлов в python', 78546]
  

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

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

Буферизация

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

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

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

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

Если политика не указана, используется значение по умолчанию:

.

  • Двоичные файлы буферизуются фрагментами фиксированного размера
  • Размер буфера выбирается в зависимости от «размера блока» нижележащего устройства.Во многих системах размер буфера обычно составляет 4096 или 8192 байта.
  • «Интерактивные» текстовые файлы (файлы, для которых isatty () возвращает True ) используют буферизацию строк. Другие текстовые файлы используют политику, описанную выше для двоичных файлов. Обратите внимание, что isatty () можно использовать, чтобы узнать, подключены ли вы к устройству Tele-TYpewriter (-like).
  импорт io
print ("Размер буфера по умолчанию:", io.DEFAULT_BUFFER_SIZE)
file = open ("test1.txt", mode = "r", buffering = 5)
распечатать файл.line_buffering)
file_contents = file.buffer
для строки в file_contents:
    печать (строка)
  
  Размер буфера по умолчанию: 8192
Ложь
b'1-я строка \ r \ n '
b'2-я строка \ r \ n '
b'3-я строка \ r \ n '
b'4-я строка \ r \ n '
b'5-я линия '
  

Примечание , что если вы используете все аргументы в порядке, указанном в open (file, mode = 'r', buffering = -1, encoding = None, errors = None, newline = None, closefd = Верно, opener = None) , имя аргумента писать не нужно! Если вы пропускаете аргументы, потому что хотите сохранить значения по умолчанию, лучше записать все полностью.

Ошибки

Необязательная строка, указывающая, как должны обрабатываться ошибки кодирования и декодирования. Этот аргумент нельзя использовать в двоичном режиме. Доступны различные стандартные обработчики ошибок (перечислены в разделе «Обработчики ошибок»).

  file = open ("test1.txt", mode = "r", errors = "strict")
печать (file.read ())
file.close ()
  
  1-я линия
2-я линия
3-я линия
4-я линия
5-я линия
  

errors = "strict" вызывает ValueErrorException , если есть ошибка кодирования.

Новая строка

новая строка управляет тем, как работает универсальный режим новой строки (применяется только к текстовому режиму). Это может быть None, '', '\ n', '\ r' и '\ r \ n'. В приведенном выше примере вы видите, что передача None в новой строки переводит '\ r \ n' в '\ n' .

  • Нет : включен универсальный режим новой строки. Строки ввода могут заканчиваться на '\ n', '\ r' или '\ r \ n', и они переводятся в разделитель строк по умолчанию

    .

  • "" : универсальный режим новой строки включен, но окончания строк возвращаются не переведенными

  • '\ n', '\ r', '\ r \ n' : строки ввода заканчиваются только заданной строкой, а окончание строки не переводится.

Обратите внимание, что универсальные символы новой строки - это способ интерпретации текстовых потоков, в котором все следующее распознается как завершение строки: соглашение Unix о конце строки '\ n', соглашение Windows '\ r \ n' и старое соглашение Macintosh '\ r'.

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

  file = open ("test1.txt", mode = "r", newline = "")
file.read ()
  
  '1-я строка \ r \ n2-я строка \ r \ n3-я строка \ r \ n4-я строка \ r \ n5-я строка'
  
  file = open ("test1.txt ", mode =" r ", newline = None)
file.read ()
  
  '1-я строка \ n2-я строка \ n3-я строка \ n4-я строка \ n5-я строка'
  
  file.close ()
  

Кодировка

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

По умолчанию кодировка зависит от операционной системы для Microsoft Windows, в Linux это cp1252, но UTF-8.Поэтому при работе с текстовыми файлами рекомендуется указывать кодировку символов. Обратите внимание, что двоичный режим не принимает аргумент кодирования.

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

  с открытым ("test1.txt", mode = "r") как файл:
    print ("Кодировка по умолчанию:", file.encoding)
    file.close ()
## изменить кодировку на utf-8
с открытым ("test1.txt ", mode =" r ", encoding =" utf-8 ") в виде файла:
    print ("Новая кодировка:", file.encoding)
    file.close ()
  
  Кодировка по умолчанию: cp1252
Новая кодировка: utf-8
  

closefd

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

Обратите внимание, что дескриптор файла - это просто целое число, присвоенное файловому объекту операционной системой, чтобы Python мог запрашивать операции ввода-вывода. Метод .fileno () возвращает это целое число.

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

  файл = открытый ("test1.txt", "r +")
fd = файл.fileno ()
print ("Назначенный дескриптор файла:", fd)

# Превращаем файловый дескриптор в файловый объект
filedes_object = open (fd, "w")
filedes_object.write ("Науки о данных \ r \ nPython")
filedes_object.close ()
  
  Назначенный дескриптор файла: 6
  

Чтобы предотвратить закрытие базового файлового объекта, вы можете использовать closefd = False :

  файл = открытый ("test1.txt", "r +")
fd = файл.fileno ()
print ("Назначенный дескриптор файла:", fd)

# Превращаем файловый дескриптор в файловый объект
filedes_object = open (fd, "w", closefd = False)
filedes_object.write («Привет»)
filedes_object.close ()
file.close ()
  
  Назначенный дескриптор файла: 6
  

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

Но что это за двоичные файлы?

Двоичные файлы хранят данные в виде 0, и 1, , которые машиночитаемы. Байт - это набор из 8 бит. Один символ хранит в памяти один 8-битный байт. Например, двоичное представление символа «H» - 01001000 , а преобразование этой 8-битной двоичной строки в десятичное дает 72 .

  binary_file = open ("binary_file.bin", режим = "wb +")
text = "Привет, 123"
закодированный = текст.кодировать ("utf-8")
binary_file.write (закодировано)
двоичный_файл.seek (0)
двоичные_данные = двоичный_файл.read ()
print ("двоичный:", двоичные_данные)
text = binary_data.decode ("utf-8")
print ("Декодированные данные:", текст)
  
  двоичный: b'Hello 123 '
Расшифрованные данные: Hello 123
  

Когда вы открываете файл для чтения в двоичном режиме b , он возвращает байты данных.

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

  для байта в binary_data:
    печать (байт)
  
  72
101
108
108
111
32
49
50
51
  

Атрибуты файлового объекта Python

Атрибуты файла предоставляют информацию о файле и состоянии файла.

  # Это еще один способ открыть файл
с открытым ("test1.txt ") в виде файла:
    print ("Имя файла:", имя_файла)
    print ("Режим файла:", file.mode)
    print ("Режим файла:", file.encoding)
    file.close ()
print ("Закрыто?", file.closed)
  
  Имя файла: test1.txt
Режим файла: r
Режим файла: cp1252
Закрыто? Правда
  

Другие методы файлового объекта

Давайте попробуем все эти методы:

  с открытым ("mynewtextfile.txt", "w +") как f:
    f.write ("Мы изучаем python \ nМы изучаем python \ nМы изучаем python")
    f.искать (0)
    печать (f.read ())
    print ("Читается:", f.readable ())
    print ("Доступен для записи:", f.writable ())
    print ("Номер файла:", f.fileno ())
    print ("Подключено к tty-подобному устройству:", f.isatty ())
    f.truncate (5)
    f.flush ()
    f.seek (0)
    печать (f.read ())
f.close ()
  
  Мы изучаем питон
Мы изучаем питон
Мы изучаем питон
Читается: True
Возможность записи: True
Номер файла: 8
Подключено к tty-подобному устройству: Ложь
Носить
  

Обработка файлов через модуль

os

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

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

Давайте посмотрим на несколько примеров этих методов:

  импорт ОС
os.getcwd ()
  
  'C: \ Users \ hda3kor \ Documents \ Reading_and_Writing_Files'
  
  ос.makedirs ("моя_папка")
  
  ------------------------------------------------ ---------------------------

FileExistsError Traceback (последний вызов последним)

 в <модуле>
----> 1 os.makedirs ("моя_папка")


C: \ Program Files \ Anaconda3 \ lib \ os.py в makedirs (имя, режим, exist_ok)
    219 возврат
    220 попыток:
-> 221 мкдир (имя, режим)
    222, кроме OSError:
    223 # Нельзя полагаться на проверку EEXIST, так как операционная система


FileExistsError: [WinError 183] Невозможно создать файл, если этот файл уже существует: 'my_folder'
  

Следующий фрагмент кода создаст папку с именем my_folder:

  открыть ("my_folder \\ newfile.txt "," w ")
print ("Содержимое папки my_folder \ n", os.listdir ("my_folder"))
Распечатать("---------------------------------")
print ("Размер папки my_folder (в байтах)", os.path.getsize ("my_folder"))
print ("Файл?", os.path.isfile ("test1.txt"))
print ("Это папка?", os.path.isdir ("my_folder"))
os.chdir ("моя_папка")
os.rename ("newfile.txt", "hello.txt")
print ("Новое содержимое папки my_folder \ n", os.listdir ("my_folder"))
  
  Содержимое папки my_folder
 ['hello.txt', 'newfile.txt']
---------------------------------
Размер папки my_folder (в байтах) 0
Файл? Правда
Папка есть? Правда



-------------------------------------------------- -------------------------

FileExistsError Traceback (последний вызов последним)

 в 
      6 print («Есть папка?», Os.path.isdir ("моя_папка"))
      7 os.chdir ("моя_папка")
----> 8 os.rename ("newfile.txt", "hello.txt")
      9 print ("Новое содержимое папки my_folder \ n", os.listdir ("my_folder"))


FileExistsError: [WinError 183] Невозможно создать файл, если этот файл уже существует: 'newfile.txt' -> 'hello.txt'
  

Если вы создадите имя файла, которое уже существует, Python выдаст ошибку FileExistsError . Чтобы удалить использование файла, вы можете использовать os.remove (имя файла) :

  ос.getcwd ()
os.remove ("hello.txt")
  

Импорт плоских файлов с помощью NumPy

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

Это также полезно для таких пакетов, как Pandas и Scikit-learn . NumPy состоит из множества встроенных функций, которые можно использовать для анализа и обработки данных: эффективно и проще.

Данные MNIST

Образец набора данных MNIST .csv можно загрузить здесь / _datasets / mnist_kaggle_some_rows.csv).

Дополнительную информацию о наборе данных MNIST можно найти здесь, на веб-странице Яна ЛеКуна.

Сначала вы импортируете модуль NumPy, а затем воспользуетесь методом loadtxt для импорта данных MNIST, как показано ниже:

  импортировать numpy как np
данные = np.loadtxt ('mnist.csv', delimiter = ',')
печать (данные)
  
  [[1.0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [1. 0. 0. ... 0. 0. 0.]
 ...
 [2. 0. 0. ... 0. 0. 0.]
 [0. 0. 0. ... 0. 0. 0.]
 [5. 0. 0. ... 0. 0. 0.]]
  

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

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

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

Давайте проверим количество строк и столбцов в этом наборе данных:

  data.shape
  
  (100, 785)
  

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

Заключение

Поздравляю с окончанием обучения.

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

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

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

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

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

Установить Python

В Linux у вас, вероятно, уже установлен Python. Если нет, вы можете установить его из репозитория программного обеспечения вашего дистрибутива. Например, в CentOS Stream или RHEL:

  $ sudo dnf установить python3  

В macOS вы можете установить Python из MacPorts или Homebrew. В Windows вы можете установить Python из Chocolatey.

После установки Python откройте свой любимый текстовый редактор и приготовьтесь писать код.

Запись данных в файл с помощью Python

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

  1. Открыть
  2. Написать
  3. Закрыть

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

В Python это означает этот процесс:

 

f = open ('example.txt', 'w')
f.write ('hello world')
f.close ()

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

Существуют различные режимы открытия файла:

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

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

Последняя строка закрывает файл.

Запись данных с использованием синтаксиса with

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

 

с open ('example.txt', 'a') как f:
f.write ('привет, открытый исходный код')

Чтение данных из файла с помощью Python

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

  1. Открыть
  2. Читать
  3. Закрыть

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

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

 f = open ('example.tmp', 'r') 

для строки в f:
print (line)

f.close ()

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

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

Чтение файла с использованием синтаксиса 'with'

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

 

с открытым ('example.txt', 'r') как f:
для строки в f:
print (line)

Файлы

и Python

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

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

Ваш адрес email не будет опубликован. Обязательные поля помечены *