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

Содержание

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Запись в файл

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

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

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

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

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

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

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

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

>>> f.close()

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

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

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

pythonworld.ru

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

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

Создание и открытие

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

Следующий код демонстрирует получение переменной file ссылки на новый документ. Если запустить эту программу, она создаст текстовый файл test.txt в папке, где хранится исходный код.

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

Если же файл с указанным именем test.txt уже существует в каталоге с кодом, программа просто продолжит работу с ним, не создавая новый документ. Как можно заметить, имя файла является первым параметром метода open. Сразу за ним следует специальная буква, которая обозначает метод обработки данных. В данном случае “w” означает write, то есть запись. Подробнее обо всех доступных режимах работы будет немного дальше, а сейчас важно усвоить, что после выполнения любых манипуляций над файлом, его обязательно следует закрыть с помощью функции close, чтобы гарантированно избежать потери информации.

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

file = open(r"D:\test.txt", "w")
file.close()

Перед строковым литералом мы использовали символ r, для отключения экранирования. Иначе компилятор посчитает последовательность “\t” как символ табуляции и выдаст исключение.

Режим открытия

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

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

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

Еще один пример: отличие “r+” и “w+” заключается в том, что во втором случае создастся новый файл, если такого нет. В первом же случае возникнет исключение. При использовании “r+” и “w+” файл будет открыт и на чтение и на запись. Пример обработки исключения разберем, когда будем рассматривать чтение файла.

Методы

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

СвойствоЗначение
nameвозвращает имя файла
modeвозвращает режим, в котором был открыт
closedвозвращает true, если файл закрыт и true, если открыт
softspaceвозвращает true, если при выводе данных из файла не следует отдельно добавлять символ пробела

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

Например:

f = open(r"D:\test.txt", "w")
print(f.name)
f.close()

D:\test.txt

Запись

В Python 3 запись в файл осуществляется с помощью метода write. Метод вызываем у объекта, который ссылается на существующий файл. Важно помнить, что для этого следует предварительно открыть документ с помощью функции open и указать режим записи символом “w”. Метод write принимает в качестве аргумента данные, которые нужно поместить в текстовый файл. Следующий пример кода показывает запись строки “hello”.

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

Если необходимо добавить новую информацию к записанным ранее данным, следует заново вызвать функцию open, указав ей в качестве режима работы символ “a”. В противном случае все сведения из файла test.txt будут полностью удалены. В приведенном ниже примере кода текстовый документ открывается для дополнительной записи, после чего в него помещается строковый литерал “ world” с пробелом вначале. Таким образом в test.txt будет располагаться “hello world”. После всего этого не нужно забывать об обязательном закрытии файла.

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

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

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

При записи бинарных данных, следует использовать режим “wb”. Вот пример записи строки в кодировке utf8:

f = open('test.dat', 'wb')
f.write(bytes('строка', 'utf8'))
f.close()

Чтение

Для чтения информации из файла в Python 3, следует вызывать метод read через объект, который ссылается на существующий документ. Также необходимо не забывать указывать “r” в качестве второго параметра функции open при открытии текстового файла.

В следующем примере read возвращает информацию из test.txt в метод print, который затем выводит сведения на экран. Как и прежде, программа завершается закрытием документа при помощи метода close. Метод read также может принимать целочисленный параметр, который используется для передачи количества символов для чтения. К примеру, введя 5, программа прочитает только hello.

try:
    file = open("test.txt", "r")
    print(file.read())
    file.close()
except FileNotFoundError:
    print('Not found')
except IOError:
    print('Something else')

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

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

Чтение бинарных данных

В случае, если данные бинарного вида — следует использовать “rb” в функции open. Рассмотрим пример:

try:
    f = open("test.dat", "rb")
    b = f.read(1)
    str = ""
    while True:
        b = f.read(1)
        if b == b'':
            break
        str += b.hex()
    print(str)
    f.close()
except IOError:
    print('error')

81d182d180d0bed0bad0b0

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

with as

Чтобы немного автоматизировать обработку текстовых файлов, рекомендуется использовать связку операторов with as. Благодаря им пропадает необходимость в вызове метода close для документа, который необходимо закрыть, поскольку это происходит автоматически. Все это демонстрируется в следующем фрагменте кода, где происходит считывание данных из test.txt. Как обычно, метод print используется для вывода строковой информации на экран.

with open('test.txt', 'r') as file:
    print(file.read())

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

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

all-python.ru

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

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

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

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

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

This is test file

line 2

line 3

this line intentionally left lank

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

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

handle = open("test.txt")

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

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

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

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

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

 

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

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

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

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

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

handle = open("test.txt", "r")

data = handle.read()

print(data)

handle.close()

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

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

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

handle = open("test.txt", "r")

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

print(data)

handle.close()

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

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

handle = open("test.txt", "r")

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

print(data)

handle.close()

Мы собрали ТОП Книг для Python программиста которые помогут быстро изучить язык программирования Python. Список книг: Книги по Python

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

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

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

handle = open("test.txt", "r") for line in handle: print(line) handle.close()

handle = open("test.txt", "r")

 

for line in handle:

    print(line)

 

handle.close()

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

handle = open("test.txt", "r") while True: data = handle.read(1024) print(data) if not data: break

handle = open("test.txt", "r")

 

while True:

    data = handle.read(1024)

    print(data)

 

    if not data:

        break

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

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

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

handle = open("test.pdf", "rb")

handle = open("test.pdf", "rb")

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

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

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

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

handle = open("output.txt", "w")

handle.write("This is a test!")

handle.close()

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

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

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

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

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

with open("test.txt") as file_handler:

    for line in file_handler:

        print(line)

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

handle = open("test.txt")

handle = open("test.txt")

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

with open("test.txt") as file_handler:

with open("test.txt") as file_handler:

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

Мы собрали ТОП Книг для Python программиста которые помогут быстро изучить язык программирования Python. Список книг: Книги по Python

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

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

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

try:

    file_handler = open("test.txt")

    for line in file_handler:

        print(line)

except IOError:

    print("An IOError has occurred!")

finally:

    file_handler.close()

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

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

try:

    with open("test.txt") as file_handler:

    for line in file_handler:

        print(line)

except IOError:

    print("An IOError has occurred!")

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

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

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

python-scripts.com

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

В этом уроке мы разберём, как читать файлы и писать в файлах в Питоне. В файлы записываются результаты работы программы, которые можно потом использовать в других приложениях. Поэтому необходимо уметь в Питон записывать информацию в файлыТакже в файлах может храниться большой объем входной информации, которую должна обработать программа. Поэтому необходимо уметь считывать информацию из файлов в python.
Чтобы начать работу с файлом  в Питон, нужно открыть файл. Открыть файл в Питон можно, прописав команду
with open(“file.ext”, mode) as name: имя перменной файла
with, open и as это ключевые слова. Команда open() открывает файл с именем “file” с разрешением файла “ext”. Параметр mode отвечает за режим открытия файла. Необходимо указать полный путь к файлу, причем используются слеши Например, можно открыть файл только для считывания информации из файла, можно открыть файл для добавления в него информации, можно просто создать новый файл с заданным именем. Название и расширение файла пишется в кавычках, расширение файла пишется после названия файла через точку, режим открытия пишется в кавычках. В таблице ниже приведены некоторые режимы открытия файла в Питон. 

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

 Разберём режим чтения файла “r”. Создайте новую программу в Spyder, сохраните её на Рабочем столе. Там же создайте текстовый документ text с расширением txt. Внутри напишите следующий текст.
1) Привет! Я первая строка.
2) Вторая строка.
3) Третья строка.
Чтобы вывести в программе  Питон  в консоль весь файл, используйте команду f.read().
Пример. Программа python читает весь файл и выводит его в консоль.
with open("text.txt", "r") as f:
    text = f.read()
    print(text)
Команда f.read(n) может принимать аргумент n, n это количество знаков с начала, которое будет считываться из файла. Например, если будет исполняться команда f.read(50), то программа выведет 50 знаков с начала файла.
Пример. Программа в Python для считывания опредленного количества знаков
with open("text.txt", "r") as f:
    text = f.read(50)
    print(text)
Если вы хотите читать текст не с начала файла, а с какого-либо символа, используйте команду f.seek(n), n это символ, с которого начнётся чтение файла. Файл начинается с нулевого символа.
Пример. Программа на Python для чтение файла с начала второй строки.
with open("text.txt", "r") as f:
    f.seek(27)
    text = f.read(50)
    print(text)
Python позволяет считать все строки текста файла в отдельный массив с помощью команды f.readlines()
Пример. Программа python выводит в консоль третью строку файла.
with open("text.txt", "r") as f:
    text = f.readlines()
    print(text[2])
Если вы хотите считывать все строки по отдельности, не записывая их в массив, используется команда f.readline()  Команда будет считывать одну строку из файла. Если использовать эту команду несколько раз, то они будут выводить разные строки. Например, если вы написали две команды f.readline(), то первая команда выведет первую строку, вторая команда выведет вторую строку.
Пример программы python считывание строк из файла с помощью команды f.readline().
with open("text.txt", "r") as f:
    text = f.readline()
    print(text)
    print(f.readline())
Часто отдельные части данных разделены каким-либо знаком. Python заменять эти знаки из строк с помощью команды f.replace(start, final), где start это знак, который надо заменить, final это знак, на который надо заменить.
Пример программы, заменяющей все пробелы в строке на знак +.
string = "Всем привет! Я строка."
print(string.replace(" ", "+"))

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

Разберём режим добавления информации в файл в Питон  “w” Для добавления информации в файл в python используется команда f.write(“text”) Эта команда удаляет весь старый текст в файле и вместо него пишет новый. Чтобы это увидеть, перед запуском программы с этой командой посмотрите в файл text.txt, там должны быть строки текста. После исполнения программы с этой командой зайдите в тот же файл, там не должно быть старых строк, вместо них будет текст, который вы написали в команде.
Пример программа на Python запись текста в файл с использованием команды f.write().
with open("text.txt", "w") as f:
    f.write("Текст.")
Вместо этого текста
1) Привет! Я первая строка.
2) Вторая строка.
3) Третья строка.
Должна появиться эта строка
Текст.
Чтобы написать несколько строк, используйте команду f.writelines(line), где line это массив со строками, которые нужно напечатать.
Пример. Программа нв Python для записи массива строк в файл
with open("text.txt", "w") as f:
    f.writelines(["Первый элемент. ", "Вторая строка."])
Разберём режим добавления информации “a”. Этот режим отличается от “w” тем, что он не удаляет старую информацию, когда пишет, в отличии от “w”. Все команды в режиме “a” идентичны командам в режиме “w”, но в режиме “a” команды не удаляют старый текст, а пишут новый в конце файла.
Разберём большой пример работы с файлами в Python. Дан текстовый файл data с двумя столбцами и десятью строками однозначных или двузначных чисел. Числа разделены пробелом. Для каждой строки нужно найти среднее этих чисел и вывести их в новый текстовый файл result.
Файл data.
11 47
59 15
2 52
64 48
58 88
59 86
37 39
19 92
48 85
16 78
Введём массив для обычных строк line[], массив для строк без пробелов aC[], массив для чисел в каждом столбце a1[] и a2[] и массив res[], в котором будут находиться средние значения.
Откроем файл data.txt и считаем из него числа. Введём цикл for на 10 итераций (повторений) по количеству строк. Считаем строку под номером i с помощью команды f.readline() и запишем её в массив с индексом i line[i].
line[i] = f.readline()
Чтобы удалить пробелы между числами, используем команду line[i].replace(“ ”, “”), при её исполнении все пробелы в строке под номером i заменятся на пустую строку. Чтобы оперировать с получившимися числами, нужно перевести их из строк в числа, для этого используется int(aC[i]). У нас получаются трёх- или четырёхзначные числа. Чтобы отделить первое число от второго, нужно использовать целочисленное деление. В целых числах разделим каждый элемент массив aC[] на 100, чтобы отбросить часть числа до сотых.
a1[i] = aC[i] // 100
Например, у нас есть число 1147, это комбинация чисел 11 и 47. Если это число мы разделим на 100, то целая часть результата будет равна 11, а остаток будет равен 47. Деление в целых числах отбрасывает остаток, оставляя только целую часть. Таким образом, мы получим первое число. Второе число будет равно остатку от деления на 100.
a2[i] = aC[i] % 100
Мы получили два числа от каждой строки. Теперь нужно найти их среднее арифметическое. Все средние значения мы запишем в массив res[i].
for i in range(10):
    res[i] = (a1[i] + a2[i]) / 2
Чтобы записать все результаты в новый файл, откроем файл result.txt в режиме “a”. С помощью цикла for запишем все результаты в отдельные строки.
with open("result.txt", "a") as result:
    for i in range(10):
        res[i] = str(res[i])
        result.write(res[i] + " ")
Полный код программы python считывание числовых столбцов из файла и запись в файл столбца средних значений
# вводим массивы
line = {} # строки
aC = {} # строки без пробелов 
a1 = {} # первое число
a2 = {} # второе число
res = {} # результат - среднее арифметическое
# выводится в новый файл

with open("data.txt", "r") as f:
    for i in range(10):
        line[i] = f.readline()
        aC[i] = line[i].replace(" ", "")
        aC[i] = int(aC[i])
        a1[i] = aC[i] // 100
        a2[i] = aC[i] % 100     
for i in range(10):
    res[i] = (a1[i] + a2[i]) / 2
    print(res[i])

with open("result.txt", "a") as result:
    for i in range(10):
        res[i] = str(res[i])
        result.write(res[i] + " ")

Вернуться к содержанию Следующая тема Библиотека NumPy в Python матрицы в питон

Поделиться:

 

itrobo.ru

Программирование на Python: Часть 8. Файловая система

Программирование на Python

Сергей Яковлев
Опубликовано 02.09.2010

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

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

https://www.ibm.com/developerworks/ru/library/?series_title_by=**auto**

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

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

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

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

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

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

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

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

  open(name[, mode[, buffering]])

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

'r' – чтение.

'w' – запись.

'a' – добавление.

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

'+' – чтение/запись.

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

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

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

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

>>> f = open('my_file', 'w')
>>> f.write('Hello, ')
>>> f.write('World!')
>>> f.close()

Чтение:

>>> f = open('my_file', 'r')
>>> f.read(5)
'Hello'
>>> f.read()
', World!'

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

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

  cat my_file | python test.py

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

test.py:
import sys
text = sys.stdin.read()
words = text.split()
wordcount = len(words)
print 'Wordcount:', wordcount

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

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

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

  seek(offset[, whence])

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

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

Пример:

>>> f = open(r'my_file', 'w')
>>> f.write('01234567890123456789')
>>> f.seek(5)
>>> f.write('Hello, World!')
>>> f.close()
>>> f = open(r'my_file')
>>> f.read()
'01234Hello, World!89'

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

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

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

  file.readline()

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

  file.readlines()

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

  file.writelines()

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

f = open(r'my_file')
lines = f.readlines()
f.close()
lines[0] = "This is a my_file2 \n" # изменяем 1-ю строку
f = open(r'my_file2','w')
f.writelines(lines)
f.close()

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

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

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

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

  try:
     # Тут идет запись в файл
  finally:
     file.close()

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

 with open("my_file") as somefile:
    do_something(somefile)

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

7. Итерация

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

f = open(filename)
while True:
  char = f.read(1)
  if not char: break
  process(char)
f.close()

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

f = open(filename)
while True:
  line = f.readline()
  if not line: break
  process(line)
f.close()

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

for line in open(filename):
  process(line)

8. Pickling

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

import pickle
t1 = [1, 2, 3]
s = pickle.dumps(t1)
t2 = pickle.loads(s)
print t2
[1, 2, 3]

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

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

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

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

   pack(format, value1, value2 ...)

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

   unpack(format, string)

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

   calcsize(format)

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

Таблица основных форматов
===========================
Format      C Type          Python 	
===========================
c             char               string of length 1 	 
?             Bool              bool 	
i 	   int                  integer 	 
l 	   long               integer 	 
f 	   float               float 	 
d 	   double           float 	 
s 	   char[]            string

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

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

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

  < - little-endian
  > - big-endian

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

from struct import *
out = open("123.bin", "wb")    
format = "if5s"                
data   = pack(format, 24,12.48,'12345')
out.write(data)
out.close()
input = open("123.bin", "rb")
data = input.read()
input.close()
format = "if5s"                   # one integer
value,value2,value3 = unpack(format, data) # note the ',' in 'value,': 
	unpack apparently returns a n-uple
print value
print value2
print value3
print calcsize(format)

>>> 24
>>> 12.4799995422
>>> 12345
>>> 13

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

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

import os
cwd = os.getcwd()
print cwd

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

  os.path.exists('my_file')

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

  os.listdir(path)

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

import os
def walk(dir):
  for name in os.listdir(dir):
    path = os.path.join(dir, name)
    if os.path.isfile(path):
        print path
    else:
        walk(path)
walk(path)

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

import os, sys
def getlocaldata(sms,dr,flst):
   for f in flst:
      fullf = os.path.join(dr,f)
      if os.path.islink(fullf): continue # don't count linked files
      if os.path.isfile(fullf):
          sms[0] += os.path.getsize(fullf)
          sms[1] += 1
      else:
          sms[2] += 1
def dtstat(dtroot):
   sums = [0,0,1] # 0 bytes, 0 files, 1 directory so far
   os.path.walk(dtroot,getlocaldata,sums)
   return sums

report = dtstat('.')
print report

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

import os, sys, fnmatch

mask = '*.py'
pattern = 'import os'

def walk(arg,dir,files):
   for file in files:
     if fnmatch.fnmatch(file,mask):
        name = os.path.join(dir,file)
        try:
          data = open(name,'rb').read()
          if data.find(pattern) != -1:
            print name
        except:
            pass    
os.path.walk('.',walk,[])

Заключение

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

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

< Предыдущая статья. Следующая статья >

Ресурсы для скачивания

Подпишите меня на уведомления к комментариям

www.ibm.com

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

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

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

my_file = open(filename, filemode)

my_file = open(filename, filemode)

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

Пример:

my_file = open("my_file.txt", "r") # Open a file print ("Name of the file: ", my_file.name) print ("Opening mode : ", my_file.mode)

my_file = open("my_file.txt", "r") # Open a file

print ("Name of the file: ", my_file.name)

print ("Opening mode : ", my_file.mode)

Вывод:

Name of the file: my_file.txt Opening mode : r

Name of the file: my_file.txt

Opening mode : r

В приведенном выше примере откройте текстовый файл с именем «my_file.txt» в режиме только чтения.

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

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

Пример:

my_file = open("my_file.txt", "r") # Open a file # do file operations. my_file.close()

my_file = open("my_file.txt", "r") # Open a file

# do file operations.

my_file.close()

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

Метод close() не совсем безопасен. Если возникает исключение, когда мы выполняем некоторую операцию с файлом, код выходит из него, не закрывая файл. Лучше использовать try ... finally block.

Пример:

try: my_file = open("my_file.txt", "r") # Open a file # do some file operations. finally: my_file.close()

try:

my_file = open("my_file.txt", "r") # Open a file

# do some file operations.

finally:

my_file.close()

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

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

Пример:

with open("my_file.txt", "r") as my_file: # do some file operations

with open("my_file.txt", "r") as my_file:

# do some file operations

В приведенном выше примере вам не нужно явно вызывать метод close(). Это делается внутренне.

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

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

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

os.rename (old_file_name, new_file_name)

os.rename (old_file_name, new_file_name)

Пример:

import os cur_file = "file1.txt" new_file = "file2.txt" os.rename(cur_file, new_file)

import os

cur_file = "file1.txt"

new_file = "file2.txt"

os.rename(cur_file, new_file)

Удаление файла в Python

Пример:

import os cur_file = "file1.txt" os.remove(cur_file)

import os

cur_file = "file1.txt"

os.remove(cur_file)

 

 

Источник: net-informations.com

bunkerbook.ru

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

< 100

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

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

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

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

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

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

www.internet-technologies.ru

Отправить ответ

avatar
  Подписаться  
Уведомление о