Как в python открыть файл: Работа с файлами в Python

Файлы. Курс «Python. Введение в программирование»

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

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

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

Функция open() – открытие файла

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

Обычно используются режимы чтения ('r') и записи ('w'). Если файл открыт в режиме чтения, то запись в него невозможна. Можно только считывать данные из него. Если файл открыт в режиме записи, то в него можно только записывать данные, считывать нельзя.

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

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

Если при вызове open() второй аргумент не указан, то файл открывается в режиме чтения как текстовый файл. Чтобы открыть файл как байтовый, дополнительно к букве режима чтения/записи добавляется символ 'b'. Буква 't' обозначает текстовый файл. Поскольку это тип файла по умолчанию, то обычно ее не указывают.

Нельзя указывать только тип файла, то есть open("имя_файла", 'b') есть ошибка, даже если файл открывается на чтение. Правильно – open("имя_файла", 'rb'). Только текстовые файлы мы можем открыть командой open("имя_файла"), потому что и 'r' и 't' подразумеваются по-умолчанию.

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

Чтение файла

С помощью файлового метода read() можно прочитать файл целиком или только определенное количество байт. Пусть у нас имеется файл data.txt с таким содержимым:

one - 1 - I
two - 2 - II
three - 3 - III
four - 4 - IV
five - 5 - V

Откроем его и почитаем:

>>> f1 = open('data.txt')
>>> f1.read(10)
'one - 1 - '
>>> f1.read()
'I\ntwo - 2 - II\nthree - 3 - III\n
four - 4 - IV\nfive - 5 - V\n'
>>> f1.read()
''
>>> type(f1.read())
<class 'str'>

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

Заметим, что метод read() возвращает строку, и что конец строки считывается как '\n'.

Для того, чтобы читать файл построчно существует метод readline():

>>> f1 = open('data.txt')
>>> f1.readline()
'one - 1 - I\n'
>>> f1.readline()
'two - 2 - II\n'
>>> f1.readline()
'three - 3 — III\n'

Метод readlines() считывает сразу все строки и создает список:

>>> f1 = open('data.txt')
>>> f1.readlines()
['one - 1 - I\n', 'two - 2 - II\n', 
'three - 3 - III\n',
'four - 4 - IV\n', 'five - 5 - V\n']

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

>>> for i in open('data.txt'):
...     print(i)
...
one - 1 - I

two - 2 - II

three - 3 - III

four - 4 - IV

five - 5 - V

>>> 

Здесь при выводе наблюдаются лишние пустые строки. Функция print() преобразует '\n' в переход на новую строку. К этому добавляет свой переход на новую строку. Создадим список строк файла без '\n':

>>> nums = []
>>> for i in open('data.txt'):
...     nums.append(i[:-1])
...
>>> nums
['one - 1 - I', 'two - 2 - II', 
'three - 3 - III', 
'four - 4 - IV', 'five - 5 - V']

Переменной i присваивается очередная строка файла. Мы берем ее срез от начала до последнего символа, не включая его. Следует иметь в виду, что '\n' это один символ, а не два.

Запись в файл

Запись в файл выполняется с помощью методов write() и writelines(). Во второй можно передать структуру данных:

>>> l = ['tree', 'four']
>>> f2 = open('newdata.txt', 'w')
>>> f2.write('one')
3
>>> f2.write(' two')
4
>>> f2.writelines(l)

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

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

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

>>> f1.close()
>>> f1.closed
True
>>> f2.closed
False

Если файл открывается в заголовке цикла (for i in open('fname')), то видимо интерпретатор его закрывает при завершении работы цикла или через какое-то время.

Практическая работа

1. Создайте файл data.txt по образцу урока. Напишите программу, которая открывает этот файл на чтение, построчно считывает из него данные и записывает строки в другой файл (dataRu.txt), заменяя английские числительные русскими, которые содержатся в списке (["один", "два", "три", "четыре", "пять"]), определенном до открытия файлов.

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

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

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

Взаимодействие с файлами в языке программирования 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 при открытии файла. Они задают режим открытия файла. Указывают программе, как именно нужно открывать. Все они представлены в следующей таблице, которая содержит их сигнатуру и короткое описание назначения.

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

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

Методы

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

Чтобы вывести на экран свойства файла, достаточно воспользоваться оператором доступа, то есть точкой, после чего передать это в качестве параметра уже знакомой функции 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, пользователь в состоянии достаточно легко выполнять основные операции по работе с чтением и записью информации в файлы.

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

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

Последнее обновление: 29.04.2017

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

При работе с файлами необходимо соблюдать некоторую последовательность операций:

1. Открытие файла с помощью метода open()

2. Чтение файла с помощью метода read() или запись в файл посредством метода write()

3. Закрытие файла методом close()

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

Чтобы начать работу с файлом, его надо открыть с помощью функции open(), которая имеет следующее формальное определение:

open(file, mode)

Первый параметр функции представляет путь к файлу. Путь файла может быть абсолютным, то есть начинаться с буквы диска, например, C://somedir/somefile.txt.
Либо можно быть относительным, например, somedir/somefile.txt — в этом случае поиск файла будет идти относительно
расположения запущенного скрипта Python.

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

• r (Read). Файл открывается для чтения. Если файл не найден, то генерируется исключение FileNotFoundError

• w (Write). Файл открывается для записи. Если файл отсутствует, то он создается. Если подобный файл уже есть, то он создается заново, и соответственно
  старые данные в нем стираются.

• a (Append). Файл открывается для дозаписи. Если файл отсутствует, то он создается. Если подобный файл уже есть,
  то данные записываются в его конец.

• b (Binary). Используется для работы с бинарными файлами. Применяется вместе с другими режимами — w или r.

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

Например, откроем для записи текстовый файл «hello.txt»:

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

myfile.close()

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

В этом случае мы можем обрабатывать исключения:

try:
    somefile = open("hello.txt", "w")
    try:
        somefile.write("hello world")
    except Exception as e:
        print(e)
    finally:
        somefile.close()
except Exception as ex:
    print(ex)

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

Однако есть и более удобная конструкция — конструкция with:

with open(file, mode) as file_obj:
	инструкции

Эта конструкция определяет для открытого файла переменную file_obj и выполняет набор инструкций. После их выполнения файл автоматически закрывается.
Даже если при выполнении инструкций в блоке with возникнут какие-либо исключения, то файл все равно закрывается.

Так, перепишем предыдущий пример:

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

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

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

Последнее обновление: 21.06.2017

Запись в текстовый файл

Чтобы открыть текстовый файл на запись, необходимо применить режим w (перезапись) или a (дозапись). Затем для записи применяется метод write(str),
в который передается записываемая строка. Стоит отметить, что записывается именно строка, поэтому, если нужно записать числа, данные других типов, то их
предварительно нужно конвертировать в строку.

Запишем некоторую информацию в файл «hello.txt»:

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

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

Теперь дозапишем в этот файл еще одну строку:

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

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

hello world
good bye, world

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

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

Для вывода данных в файл в метод print в качестве второго параметра передается название файла через параметр file. А первый параметр представляет записываемую
в файл строку.

Чтение файла

Для чтения файла он открывается с режимом r (Read), и затем мы можем считать его содержимое различными методами:

• readline(): считывает одну строку из файла

• read(): считывает все содержимое файла в одну строку

• readlines(): считывает все строки файла в список

Например, считаем выше записанный файл построчно:

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

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

Теперь явным образом вызовем метод readline() для чтения отдельных строк:

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

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

hello world
good bye, world

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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)

Вывод:

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()

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

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

Пример:

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

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

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

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

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

os.rename (old_file_name, new_file_name)

Пример:

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)

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

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

Я хочу на самом деле открыть его , а не просто прочитать.

Я пытался сделать что-то вроде этого:

x = open("filename", "r")
abc = x.read()
x.close()

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

Этот файл является файлом «bat»

python-3.x

Поделиться

Источник

ron cohen    

11 мая 2015 в 15:28

2 ответа

• Как открыть файл, нажав кнопку в Python 3

  Я хочу открыть файл (HTML web document), нажав кнопку в строке меню. Я использую Python 3.4 и Windows 7 64-bit. Как бы я это сделал? Документ HTML сохранен на моем компьютере, я хочу, чтобы он открыл его с моего компьютера.

• Python 3-открыть файл из консоли

  Я пытаюсь запустить команду open() в файле из консоли python в terminal, а не с помощью скрипта. Например, я бы набрал следующее, чтобы присвоить файл переменной ‘txt’: >>> txt = open(C:\\user\\documents\\python\\ex15_sample.txt) Вот результат: File <stdin>, line 1 txt =…

3

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

os.startfile('path/to/file.ext') # opens file in respective program

Поделиться

Malik Brahimi    

11 мая 2015 в 15:31

0

Вы должны вызвать filename. bat

Кроме того, явный .read() может быть удален в abc = x.read() .

Поделиться

Mark    

15 января 2018 в 15:34

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

Как открыть файл через python

Я очень новичок в программировании и языке python. Я знаю, как открыть файл в python, но вопрос в том, как я могу открыть файл в качестве параметра функции? пример: function(parameter) Вот как я…

как открыть файл xlsx с помощью python 3

У меня есть файл xlsx с 1 листом. Я пытаюсь открыть его с помощью python 3 (xlrd lib), но получаю пустой файл! Я использую этот код: file_errors_location = C:\\Users\\atheelm\\Documents\\python…

Как открыть файл в python из документов

Привет, я уже знаю, как открыть файл в python 3, но есть ли способ открыть файл в C:\Users\user\Documents (пользователь-это пользователь вошедшего в систему компьютера). Поэтому я хочу открыть…

Как открыть файл, нажав кнопку в Python 3

Я хочу открыть файл (HTML web document), нажав кнопку в строке меню. Я использую Python 3.4 и Windows 7 64-bit. Как бы я это сделал? Документ HTML сохранен на моем компьютере, я хочу, чтобы он…

Python 3-открыть файл из консоли

Я пытаюсь запустить команду open() в файле из консоли python в terminal, а не с помощью скрипта. Например, я бы набрал следующее, чтобы присвоить файл переменной ‘txt’: >>> txt =…

Как открыть защищенный паролем файл zip в Python 3

Я пытаюсь открыть защищенный паролем файл zip в Python. Однако я совершенно застрял! Я просмотрел документацию python по файлам zip, но не могу найти ничего, чтобы открыть тот, который защищен…

открыть файл доступа в python

Я не могу открыть файл access с помощью python. Я не уверен, что проблема связана с файлом mdb или командами python. In [1]: import sys, subprocess In [2]: DATABASE = ‘Exam_BackUp.mdb’ In [3]:…

Как открыть программу Python 3 в другой папке внутри Python 3

Я хотел бы открыть программу Python 3 внутри Python 3, но целевая программа находится в другой папке. EG: Pythonloader.py > PythonFolder > Target.py Я использую Python 3.3.0

Открыть файл внутри Python

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

Как открыть файл python с помощью cmd

Привет работал над проектом, и я пытался открыть файл python с помощью python. До сих пор я знал, что это невозможно, но я узнал, что вы можете сделать это с cmd. У меня есть код, который может…

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

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

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

with open(«C:\Users\user\Desktop\Win\Python\settings\data.txt»,»r») as f:

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

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

 Разберём режим чтения из файла “r”. Создайте новую программу в Spyder, сохраните её на Рабочем столе.  Создайте на рабочем столе текстовый документ text с расширением txt. Внутри файла напишите следующий текст.

 Привет! Я первая строка.

 Вторая строка.

Третья строка.

Чтобы вывести в программе Питон  в консоль весь файл, используется команда 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”) Эта команда удаляет весь старый текст в файле и вместо него пишет новый. После исполнения программы с этой командой зайдите в тот же файл, там не должно быть старых строк, вместо них будет текст, который вы написали в команде.
Пример программа на Python запись текста в файл с использованием команды f.write().
with open(«text.txt», «w») as f:

    f.write(«Текст.»)

Вместо этого текста

Привет! Я первая строка.

Вторая строка.

Третья строка.

Должна появиться эта строка

Текст.

Чтобы написать несколько строк, используется команда f.writelines(line), где line это массив со строками, которые нужно записать в файл
Программа на Python для записи массива строк в файл
with open(«text.txt», «w») as f:

    f.writelines([«Первый элемент. «, «Вторая строка.»])

Разберём режим добавления информации “a”. Этот режим отличается от “w” тем, что он не удаляет старую информацию. Все команды в режиме “a” идентичны командам в режиме “w”, но в режиме “a” команды не удаляют старый текст, а записывают текст в конце файла.

Часто в программах на python входная информация считывается из файла, обрабатывается и результат записывается в новый выходной файл. Разберём большой пример работы с файлами в 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() и запишем её в массив с индексом line[i]
line[i] = f.readline()

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

Для считывания всех строк файла и перевода их в массивы необходимо написать следующий код
line = {} # строки

with open(«C:\Users\user\Desktop\Win\Python\settings\data.txt»,»r») as f:

    for i in range(10):

        line[i] = f.readline()

        stroka=line[i].split(‘ ‘)

Чтобы получить из строки stroka числовые значения первого элемента и второго, воспользуемся функцией int(). В массив res[i] запишем среднее арифметическое двух элементов строки

       a=int(stroka[0])

       b=int(stroka[1])

       res[i]=(a+b)/2

Чтобы записать все результаты в новый файл, откроем файл result. txt в режиме “a”. С помощью цикла for запишем все результаты в отдельные строки.
with open(«C:\Users\user\Desktop\Win\Python\settings\result.txt», «a») as result:

    for i in range(10):

        res[i] = str(res[i])

        result.write(res[i] + » «)
Полный код программы python считывание числовых столбцов из файла и запись в файл столбца средних значений

line = {} # строки

res={}

with open(«C:\Users\user\Desktop\Win\Python\settings\data.txt»,»r») as f:

    for i in range(10):

        line[i] = f.readline()

        stroka=line[i].split(‘ ‘)

        a=int(stroka[0])

        b=int(stroka[1])

        res[i]=(a+b)/2

with open(«C:\Users\user\Desktop\Win\Python\settings\result.txt», «a») as result:

    for i in range(10):

        res[i] = str(res[i])

        result.write(res[i] + » «)

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

Поделиться:

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

Открыть файл на сервере

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

demofile. txt

Привет! Добро пожаловать в demofile.txt
Этот файл предназначен для тестирования.
Хорошо
Удача!

Чтобы открыть файл, используйте встроенную функцию open () .

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

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

Пример

Откройте файл в другом месте:

f = open («D: \\ myfiles \ welcome.txt «,» r «)
print (f.read ())

Пример запуска »

Части файла, доступные только для чтения

По умолчанию метод read () возвращает весь текст, но вы также можете указать, сколько символов вы хотите вернуть:

Пример

Вернуть 5 первых символов файла:

f = open («demofile.txt», «r»)
print (f.read ( 5 ))

Пример запуска »

Прочитать строки

Вы можете вернуть одну строку с помощью метода readline () :

Пример

Прочитать одну строку файла:

f = open («демофайл. txt «,» r «)
print (f.readline ())

Пример запуска »

Дважды позвонив readline () , можно прочитать
две первые строки:

Пример

Прочитать две строки файла:

f = open («demofile.txt», «r»)
print (f.readline ())
print (f.readline ())

Пример запуска »

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

Пример

Цикл по файлу построчно:

f = open («демофайл.txt «,» r «)
для x в f:
print (x)

Пример запуска »

Закрыть файлы

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

Пример

Закройте файл, когда закончите с ним:

f = open («demofile.txt», «r»)
print (f.readline ())
f.close ()

Пример запуска »

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

Открыть файл в Python

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

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

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

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

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

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

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

Синтаксис:

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

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

Пример № 1: Предположим, текстовый файл выглядел так.

Мы хотим прочитать содержимое файла с помощью Python.

Вывод:

Добро пожаловать в GeeksForGeeks !!
 

Пример № 2: Предположим, мы хотим записать больше данных в указанный выше файл с помощью Python.

Вывод:

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

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

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

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

Давайте сразу перейдем к примеру кода.Представьте, что у вас есть файл с именем example.txt в текущем каталоге. Если вы этого не сделаете, просто создайте его, а затем заполните его этими строками и сохраните:

  привет мир
и сейчас
Я говорю
до свидания
  

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

  myfile = open ("example.txt")
txt = myfile.читать()
печать (txt)
myfile.close ()
  

Это показалось слишком сложным? Вот менее подробная версия:

  myfile = open ("example.txt")
печать (myfile.read ())
myfile.close ()
  

Вот как прочитать этот файл построчно, используя цикл for:

  myfile = open ("example.txt")
для строки в myfile:
    печать (строка)
myfile.close ()
  

(Примечание: если вы получаете FileNotFoundError уже - этого почти следовало ожидать.Продолжайте читать!)

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

А теперь давайте рассмотрим это по порядку.

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

  myfile = open ("example. текст")
  

Это кажется достаточно простым, поэтому давайте перейдем к некоторым распространенным ошибкам.

Как напортачить при открытии файла

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

  FileNotFoundError: [Errno 2] Нет такого файла или каталога: 'SOME_FILENAME'
  

На самом деле, я видел, как студенты тратили десятки часов, пытаясь обойти это сообщение об ошибке, потому что они не останавливаются, чтобы прочитать его .Итак, прочтите это : Что означает FileNotFoundError ?

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

 Ошибка  Файл не найден
  

Вы получите эту ошибку, потому что вы пытались открыть файл, которого просто не существует. Иногда это простая опечатка: open () пытается открыть файл с именем "example.txt" , но случайно неправильно его написала как "exmple. txt" .

Но чаще всего это происходит потому, что вы знаете, что файл существует под данным именем, например, "пример.txt " - но как ваш код Python узнает, где находится этот файл? Это " example.txt ", который существует в вашей папке Downloads ? Или тот, который может существовать в вашей папке Documents ? Или тысячи других папок в вашей компьютерной системе?

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

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

Как исправить ошибку FileNotFoundError

Вот верное решение: убедитесь, что файл действительно существует.

Начнем с нуля, сделав ошибку. В вашей системной оболочке (т.е. Терминале) перейдите в папку Desktop :

  $ cd ~ / Рабочий стол
  

Теперь запустите ipython :

  $ ipython
  

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

  >>> myfile = open ("whatdude.текст")
  

  ------------------------------------------------ ---------------------------
FileNotFoundError Traceback (последний вызов последним)
 в  ()
----> 1 myfile = open ("whatdude. txt")

FileNotFoundError: [Errno 2] Нет такого файла или каталога: 'anydude.txt'
  

Теперь вручную создайте файл на рабочем столе , используя Sublime Text 3 или что угодно.Добавьте к нему текст, затем сохраните его.

  это
мой
файл
  

Посмотрите и убедитесь сами, что этот файл действительно существует в вашей папке Desktop :

Хорошо, теперь переключитесь обратно на вашу интерактивную оболочку Python (например, ipython ), ту, которую вы открыли после перехода в папку Desktop (например, cd ~ / Desktop ). Повторно запустите команду open () , которая привела к ошибке FileNotFoundError :

  >>> myfile = open ("whatdude.текст")
  

Надеюсь, вы не получите ошибку.

Но что это за объект, на который указывает переменная myfile ? Используйте метод type () , чтобы выяснить это:

  >>> тип (myfile)
 _io.TextIOWrapper
  

А что это за , что за ? Детали не важны, кроме как указать, что myfile определенно не просто строковый литерал, то есть str .

Используйте Tab автозаполнения (т.е.е. введите myfile. ), чтобы получить список существующих методов и атрибутов для объекта myfile :

  myfile.buffer myfile.isatty myfile.readlines
myfile.close myfile.line_buffering myfile.seek
myfile.closed myfile.mode myfile.seekable
myfile.detach myfile.name myfile.tell
myfile.encoding myfile.newlines myfile.truncate
myfile.errors myfile.read myfile.writable
мой файл.fileno myfile.readable myfile.write
myfile.flush myfile.readline myfile.writelines
  

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

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

  >>> mystuff = myfile.read ()
  

Что находится в этой переменной mystuff ? Снова используйте функцию type () :

  >>> тип (mystuff)
ул.
  

Это просто строка.Что, конечно, означает, что мы можем его распечатать:

  >>> печать (mystuff)
это
мой
файл
  

Или посчитайте количество символов:

  >>> len (mystuff)
15
  

Или распечатайте прописными буквами:

  >>> print (mystuff.upper ())
ЭТО
МОЙ
ФАЙЛ
  

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

Теперь об ошибках.

Как напортачить при чтении из файла

Вот очень-очень распространенная ошибка:

  >>> filename = "пример.текст"
>>> filename.read ()
  

Вывод ошибки:

  AttributeError Traceback (последний вызов последним)
 в  ()
----> 1 имя_файла.read ()

AttributeError: объект 'str' не имеет атрибута 'read'
  

Обратите внимание, что это , а не , а FileNotFoundError . Это AttributeError , что, по общему признанию, не очень понятно, но прочтите следующую часть:

  объект 'str' не имеет атрибута 'read'
  

Сообщение об ошибке доходит до сути: объект str - i.е. строковый литерал, например что-то вроде "hello world" не имеет атрибута read .

Возвращаясь к ошибочному коду:

  >>> filename = "example.txt"
>>> filename.read ()
  

Если filename указывает на «example.txt», то filename - это просто объект str .

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

  >>> "пример.txt ".read ()
  

И бить по голове:

  >>> "привет мир, это всего лишь строка" .read ()
  

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

К сожалению, мы должны проявлять осторожность, пытаясь прочитать файл программно. Открытие файла - это отдельная операция от чтения его.

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

Опять же, вот код, немного более подробный:

  >>> myfilename = "пример.текст"
>>> myfile = open (myfilename)
>>> mystuff = myfile.read ()
>>> # сделать что-нибудь с mystuff, например распечатать или что-то в этом роде
>>> myfile.close ()
  

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

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

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

  >>> myfile = open ("example.текст")
>>> mystuff = myfile.read ()
  

Сейчас это не кажется таким уж большим делом, но это потому, что example.txt , вероятно, содержит всего несколько строк. Но когда мы имеем дело с файлами, которые составляют массивных - как и все 3,3 миллиона записей всех, кто пожертвовал более 200 долларов единственному комитету президентской кампании США в 2012 году или всех, кто когда-либо посещал Белый дом, - открытие и чтение файла все сразу заметно медленнее. И это может даже привести к сбою вашего компьютера.

Если вам интересно, почему программное обеспечение для работы с электронными таблицами, такое как Excel, имеет ограничение на количество строк (примерно 1 000 000), это потому, что большинство пользователей – хотят работать с файлом данных одновременно. Однако многие интересные файлы данных слишком велики для этого. Мы столкнемся с этими сценариями позже в этом квартале.

А пока вот как обычно выглядит построчное чтение:

  myfile = open ("example.txt")
для строки в myfile:
    печать (строка)
myfile.close ()
  

Поскольку каждая строка в текстовом файле содержит символ новой строки (который представлен как \ n , но обычно «невидим»), вызов функции print () создаст вывод с двойным интервалом, потому что print () добавляет новую строку к тому, что он выводит (т.е. вспомните свою исходную программу print ("hello world") ).

Чтобы избавиться от этого эффекта, вызовите метод strip () , который принадлежит объектам str и удаляет символы пробела с левой и правой стороны текстовой строки:

  myfile = open ("example.txt")
для строки в myfile:
    печать (line.strip ())
myfile.close ()
  

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

  myfile = open ("example.текст")
для строки в myfile:
    печать (line.strip ())
myfile.close ()
  

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

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

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

Ключевые методы, предоставляемые нам Python для обработки файлов: open () , close () , write () , read () , seek () и append () .

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

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

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

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

Python Open File Sample File Content

1. Открытие файла с помощью метода open ()

Чтобы открыть OpenFile.txt и прочитать текстовое содержимое файла, давайте воспользуемся open (), и read () методов.

файл = открытый ('OpenFile.txt')
распечатать файл.читать())
file.close ()
 

Метод read () прочитает все содержимое файла.

Python Вывод открытого файла

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

2. Различные режимы для метода open ()

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

файл = открытый ('OpenFile.txt')
печать (file.read ())
file.write («тестовая запись»)
файл.Закрыть()
 

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

Запись в файл не разрешена, режим только для чтения

Итак, что такое режимы и как их добавить? Ниже приведен список режимов при использовании метода open ().

• r : режим только для чтения.
• r +: Режим чтения и записи. Не будет создавать новый файл, и открытие не удастся, если файл не существует
• rb : двоичный режим только для чтения для чтения изображений, видео и т. Д.
• w: Режим только записи. Заменяет существующее содержимое файла. Это создаст новый файл, если указанное имя файла не существует.
• w +: Режим чтения и записи.
• wb: Двоичный режим только для записи для записи в медиафайлы.
• wb +: Двоичный режим чтения и записи.
• a: Режим добавления. Не перезаписывает существующее содержимое.
• a +: Режим добавления и чтения. Он создаст новый файл, если имя файла не существует.
• ab: Добавить двоичный режим для изображений, видео и т. Д.
• ab +: Добавить и прочитать двоичный режим.

3. Открытие файлов в режиме записи в Python

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

file = open ('OpenFile.txt', 'ш')
печать (file.read ())
file.close ()
 

Добавляя «w» при открытии файла в первую строку, мы указываем, что файл должен быть открыт в режиме записи.Но эта операция не сработает, тоже , потому что файл предназначен только для записи и не позволяет нам использовать метод read ().

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

file = open ('OpenFile.txt', 'ш')
file.write ('Новое содержимое \ n')
file.close ()
 

Приведенный выше код полностью очистит все содержимое текстового файла и вместо этого просто скажет «Новое содержимое».

Если вы не хотите перезаписывать файл, вы можете использовать режимы a + или r + .

В режиме r + будет записано любое содержимое, переданное методу write () .

файл = открытый ('OpenFile.txt', 'r +')
печать (file.read ())
file.write ('метод r +, добавляет строку \ n')
file.close ()
 

Режим a или a + выполняет то же действие, что и режим r +, с одним основным отличием.

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

4. Открытие файлов с помощью предложения with

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

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

с open ('OpenFile.txt', 'r +') как файл:
    печать (file.read ())
 

Python: вывод открытого файла

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

Блок с блоком получает блокировку, как только он выполняется, и снимает блокировку после завершения блока.

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

с open ('OpenFile.txt', 'r +') как файл:
    lines = file.readlines ()
    
    для строки в строках:
        печать (line.split ())
 

С помощью команды Открыть файл Python 1

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

Заключение

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

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

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

Основы файлов в Python

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

При открытии файла для чтения Python должен точно знать, как файл должен быть открыт в системе.Доступны два режима доступа - чтение и чтение в двоичном режиме. Соответствующие используемые флаги: r и rb , и должны быть указаны при открытии файла с помощью встроенного метода open () . Первый режим включает интерпретацию специальных символов, таких как «CR» (возврат каретки) и «LF» (перевод строки), для представления разрывов строки, тогда как двоичный режим позволяет вам читать данные в необработанном режиме, где данные хранятся как без дальнейшей интерпретации.

После открытия файла метод open () вернет вам объект файла.Эти файловые объекты имеют такие методы, как read () , readline () , write () , tell () и seek () . Хотя некоторые файловые объекты (или файловые объекты) имеют больше методов, чем перечисленные здесь, они являются наиболее распространенными. Не все файловые объекты должны реализовывать все файловые методы.

Примеры

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

Чтение файла строка за строкой

Первый пример основан на двух языках программирования C и C ++. Это довольно просто: откройте файл с помощью метода open () , прочтите файл построчно с помощью метода readline () и выведите строку сразу после чтения. Здесь используется цикл и , который непрерывно читает из файла, пока метод readline () продолжает возвращать данные.В случае, если конец файла (EOF) достигается , в то время как цикл останавливается и объект файла закрывается, освобождая ресурсы для использования другими программами.

  # определяем имя файла для чтения
filename = "test.txt"

# открываем файл для чтения
filehandle = open (имя файла, 'r')
в то время как True:
    # читать одну строку
    строка = filehandle.readline ()
    если не строка:
        перерыв
    печать (строка)

# закрываем указатель на этот файл
filehandle.close ()
  

Листинг 1

Как вы, возможно, заметили в листинге листинг 1 , мы явно открыли и закрыли файл (строки 5 и 14 соответственно).Хотя интерпретатор Python автоматически закрывает открытые файлы в конце выполнения программы Python, явное закрытие файла с помощью close () является хорошим стилем программирования, и о нем нельзя забывать.

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

  # определяем имя файла для чтения
filename = "test.txt"

для открытой строки (имя файла, 'r'):
    печать (строка)
  

Листинг 2

Здесь используется цикл для в сочетании с итератором в .Файл открывается в строке 4 из Листинг 2 . Текущая строка идентифицируется с помощью итератора в , читается из файла, и ее содержимое выводится на stdout в строке 5. Python покрывает открытие и закрытие файла для вас, когда он выпадает из области видимости. Хотя это неэффективно, это позволяет вам больше не иметь дело с дескрипторами файлов.

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

  # определяем имя файла для чтения
filename = "test.txt"

с open (filename, 'r') в качестве дескриптора файла:
    для строки в дескрипторе файла:
        печать (строка)
  

Листинг 3

Комбинация оператора с оператором и команды open () открывает файл только один раз (строка 4).В случае успеха выполняется цикл для , и содержимое строки печатается на stdout (строки 5 и 6).

Кроме того, использование с оператором имеет побочный эффект. Внутренне интерпретатор Python создает try - , наконец, -блок для инкапсуляции чтения из файла. Листинг 4 показывает, что по сути происходит внутри Python с с блоками кода :

  попробуйте:
    filehandle = open (имя файла, 'r')
    # сделай что-нибудь
наконец-то:
    дескриптор файла.Закрыть()
  

Листинг 4

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

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

  из itertools import islice

# определяем имя файла для чтения
filename = "test.txt"

# определяем количество строк для чтения
number_of_lines = 5

с open (filename, 'r') как input_file:
    lines_cache = islice (файл_входа, число_строков)
   
    для current_line в lines_cache:
        печать (текущая_строка)
  

Листинг 5

Чтение определенной строки из файла

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

  # определяем имя файла для чтения
filename = "test.txt"

# определяем номер строки
line_number = 3

print ("строка% i% s:"% (номер_строки, имя файла))

с open (filename, 'r') в качестве дескриптора файла:
current_line = 1
    для строки в дескрипторе файла:
        если current_line == line_number:
            печать (строка)
            перерыв
        current_line + = 1
  

Листинг 6

Листинг 6 должен быть простым для понимания, но он немного длиннее, чем в предыдущих примерах.Его можно сократить с помощью модуля linecache. Листинг 7 показывает, как упростить код с помощью метода getline () . Если запрошенный номер строки выпадает из диапазона допустимых строк в файле, тогда метод getline () вместо этого возвращает пустую строку.

  # import linecache module
импорт строчного кэша

# определяем имя файла для чтения
filename = "test.txt"

# define line_number
line_number = 3

# получить конкретную строку
line = linecache.getline (имя файла, номер_строки)
print ("строка% i из% s:"% (номер_строки, имя файла))
печать (строка)
  

Листинг 7

Чтение всего файла сразу

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

  # определяем имя файла для чтения
filename = "test.txt"

с open (filename, 'r') в качестве дескриптора файла:
    filecontent = filehandle.read ()
    печать (содержимое файла)
  

Листинг 8

Python также предлагает метод readlines () , который аналогичен методу readline () из первого примера. В отличие от read () , содержимое файла хранится в списке, где каждая строка содержимого является элементом. Листинг 9 показывает, как получить доступ к этим данным:

  # определяем имя файла для чтения
filename = "test.txt"

с open (filename, 'r') в качестве дескриптора файла:
    filecontent = filehandle.readlines ()
    для строки в содержании файла:
        печать (строка)
  

Листинг 9

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

Заключение

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

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

ресурсов

Благодарности

Автор благодарит Золеку Хатитонгве за поддержку при подготовке статьи.

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

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

Любые файловые операции можно выполнить в следующие три шага:

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

Чтение файла

Файловый объект включает следующие методы для чтения данных из файла.

• read (chars): читает указанное количество символов, начиная с текущей позиции.
• readline (): читает символы, начиная с текущей позиции чтения до символа новой строки.
• readlines (): читает все строки до конца файла и возвращает объект списка.

Следующий файл C: \ myfile.txt будет использоваться во всех примерах чтения и записи файлов.

  Это первая строка.Это вторая строка.
Это третья строка.
  

В следующем примере выполняется операция чтения с использованием метода read (chars) .

  >>> f = open ('C: \ myfile.txt') # открытие файла
>>> lines = f.read () # чтение файла
>>> линии
«Это первая строка. \ nЭто вторая строка. \ nЭто третья строка. '
>>> f.close () # закрытие файлового объекта
  

Вверху: f = open ('C: \ myfile.txt ') открывает myfile.txt в режиме чтения по умолчанию из текущего каталога и возвращает объект файла.
f.read () Функция считывает все содержимое до EOF в виде строки. Если вы укажете аргумент размера символа в методе read (chars) , тогда он будет читать только это количество символов.
f.close () очистит и закроет поток.

Чтение строки

В следующем примере показано чтение строки из файла.

  >>> f = open ('C: \ myfile.txt') # открытие файла
>>> line1 = f.readline () # чтение строки
>>> line1
«Это первая строка. \ п '
>>> line2 = f.readline () # чтение строки
>>> line2
'Это вторая строка. \ N'
>>> line3 = f.readline () # чтение строки
>>> line3
«Это третья строка».
>>> line4 = f.readline () # чтение строки
>>> line4
''
>>> е.close () # закрытие файлового объекта
  

Как видите, нам нужно открыть файл в режиме 'r' . Метод readline () вернет первую строку, а затем укажет на вторую строку в файле.

Чтение всех строк

Следующий код считывает все строки с помощью функции readlines () .

  >>> f = open ('C: \ myfile.txt') # открытие файла
>>> lines = f.readlines () # чтение всех строк
>>> линии
«Это первая строка. \ nЭто вторая строка. \ nЭто третья строка. '
>>> f.close () # закрытие файлового объекта
  

Файловый объект имеет встроенный итератор. Следующая программа читает данный файл построчно до тех пор, пока не будет поднято StopIteration , то есть не будет достигнут EOF.

  f = open ('C: \ myfile.текст')
в то время как True:
    пытаться:
        строка = следующий (е)
        печать (строка)
    кроме StopIteration:
        перерыв
f.close ()
  

Используйте цикл for, чтобы легко прочитать файл.

  f = открытый ('C: \ myfile.txt')
для строки в f:
    печать (строка)
f.close ()
  

  Это первая строка.
Это вторая строка.Это третья строка.
  

Чтение двоичного файла

Используйте режим 'rb' в функции open () для чтения двоичных файлов, как показано ниже.

  >>> f = open ('C: \ myimg.png', 'rb') # открытие двоичного файла
>>> content = f.read () # чтение всех строк
>>> содержание
б '\ x89PNG \ r \ n \ x1a \ n \ x00 \ x00 \ x00 \ rIHDR \ x00 \ x00 \ x00 \ x08 \ x00 \ x00 \ x00 \ x08 \ x08 \ x06
\ x00 \ x00 \ x00 \ xc4 \ x0f \ xbe \ x8b \ x00 \ x00 \ x00 \ x19tEXtSoftware \ x00Adobe ImageReadyq
\ xc9e \ x00 \ x00 \ x00 \ x8dIDATx \ xdab \ xfc \ xff \ xff? \ x03 \ x0c0 / zP \ n \ xa4b \ x818 \ xeco \ x9c
\ xc2 \ r \ x90 \ x18 \ x13 \ x03 * 8 \ t \ xc4b \ xbc \ x01 \ xa8X \ x07 $ \ xc0 \ xc8 \ xb4 \ xf0> \\\ x11P \ xd7?
\ xa0 \ x84 \ r \ x90 \ xb9 \ t \ x88? \ x00q H \ xc1C \ x16 \ xc9 \ x94_ \ xcc \ x025 \ xfd2 \ x88 \ xb1 \ x04
\ x88 \ x85 \ x90 \ x14 \ xfc \ x05 \ xe2 (\ x16 \ x00 \ xe2 \ xc3 \ x8c \ xc8 \ x8e \ x84: \ xb4 \ x04H5 \ x03
\ xf1 \\.bD \ xf3E \ x01 \ x90 \ xea \ x07 \ xe2 \ xd9 \ xaeB` \ x82 '
>>> f.close () # закрытие файлового объекта
  

Запись в файл

Файловый объект предоставляет следующие методы записи в файл.

• запись (и): записать строку s в поток и вернуть количество записанных символов.
• строк записи (строк): записать список строк в поток. В конце каждой строки должен быть разделитель.

Создать новый файл и записать

Следующий код создает новый файл, если он не существует, или перезаписывает существующий файл.

  >>> f = open ('C: \ myfile.txt', 'w')
>>> f.write ("Hello") # запись в файл
5
>>> f.close ()

# чтение файла
>>> f = open ('C: \ myfile.txt', 'r')
>>> f.read ()
'Привет'
>>> f.close ()
  

В приведенном выше примере f = open ("myfile.txt "," w ") оператор открывает myfile.txt в режиме записи, метод open () возвращает объект файла и присваивает его переменной f .
'w' указывает, что файл должен быть доступен для записи.
Затем f.write («Привет») перезаписывает существующее содержимое файла myfile.txt . Он возвращает количество символов, записанных в файл, которое в приведенном выше примере равно 5.
В конце f.close () закрывает файловый объект.

Добавление к существующему файлу

Следующий код добавляет содержимое в конец существующего файла, передавая 'a' или 'a +' mode в методе open () .

  >>> f = open ('C: \ myfile.txt', 'a')
>>> f.write ("Мир!")
7
>>> f.close ()

# чтение файла
>>> f = open ('C: \ myfile.txt', 'r')
>>> е.читать()
'Привет мир!'
>>> f.close ()
  

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

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

  >>> lines = ["Hello world. \ N", "Добро пожаловать в TutorialsTeacher.\ n "]
>>> f = open ("D: \ myfile.txt", "w")
>>> f.writelines (строки)
>>> f.close ()
  

Открытие файла в режиме «w» или «a» может быть только записано, но не может быть прочитано. Аналогичным образом режим «r» позволяет только чтение, но не запись.
Для одновременного выполнения операций чтения / добавления используйте режим «a +».

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

Функция open () по умолчанию открывает файл в текстовом формате.Чтобы открыть файл в двоичном формате, добавьте 'b' к параметру режима.
Следовательно, режим «rb», открывает файл в двоичном формате для чтения, а режим «wb» открывает файл в двоичном формате для записи. В отличие от текстовых файлов, двоичные файлы не читаются человеком. При открытии с помощью любого текстового редактора данные невозможно распознать.

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

  f = open ("binfile.bin", "wb")
число = [5, 10, 15, 20, 25]
arr = bytearray (число)
f.write (обр.)
f.close ()
  

Как читать и записывать файлы в Python - Linux Hint

Файлы используются для постоянного хранения любых данных для будущего использования. Чтение из файла и запись в файл - общие требования для любого языка программирования.Любой файл необходимо открыть перед чтением или записью. Большинство языков программирования используют метод open () для открытия файла для чтения или записи с использованием файлового объекта. Различные типы режима доступа к файлу могут использоваться в качестве аргумента метода open () для указания цели открытия файла. Это необязательный аргумент. Метод close () используется после завершения файловой операции для освобождения ресурсов, занятых файловым объектом. Программирование на Python может обрабатывать файлы двух типов. Это текстовый файл и двоичный файл.В этом руководстве описано, как читать и писать текстовые файлы в программировании на Python.

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

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

Методы:

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

Этот метод содержит два аргумента. Первый аргумент является обязательным и используется для чтения или записи имени файла. Второй аргумент является необязательным, он используется для установки режима доступа к файлу. Режим доступа к файлам по умолчанию - ‘rt’ . Тип возврата этого метода - файловый объект, который используется для чтения и записи файла.

Синтаксис:

FileObject = open («Имя файла», «FileMode»)
close ():

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

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

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

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

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

Чтение текстового файла:

Создайте текстовый файл с именем ‘ countryList.txt ’ со следующим содержанием, чтобы использовать его в следующей части статьи.

Алжир
Багамы
Бельгия
Куба
Финляндия

Пример 1: Чтение файла с помощью read (), readline () и readlines ()

Создайте файл с именем read1.py с помощью следующего скрипта Python. Он будет читать файл на основе размера байта с помощью read () , считывать фиксированное количество символов из файла с помощью readline () и читать все строки файла в массиве с помощью readlines ().

# Открыть файл для чтения
FileHandler = open ("countryList.txt", "r")

# Прочитать содержимое файла на основе размера
print ('Вывод из метода read () \ n', FileHandler.read (2048))

# Закройте файл
FileHandler.close ()

# Открыть файл для чтения и записи
FileHandler = open ("countryList.txt", "r +")

# Прочитать содержимое файла третьей строки
print ('Вывод из метода readline () \ n ', FileHandler.readline (5))

# Закройте файл
FileHandler.close ()

# Открыть файл для чтения и добавления
FileHandler = open ("countryList.txt", "r")

# Прочитать все содержимое файла
print ('Вывод из метода readlines () \ n', FileHandler.readlines ())

# Закройте файл
FileHandler.close ()

Выход:

После запуска сценария появится следующий вывод.

Пример 2: Чтение файла построчно с использованием цикла

Создайте файл с именем read2.py следующим скриптом. Он будет читать и печатать каждую строку файла из fileObject , используя цикл for.

# Открыть файл для чтения
fileObject = open ("countryList.txt", "r")

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

Выход:

После запуска сценария появится следующий вывод.

Пример 3: Чтение файла с использованием с оператором

Создайте файл с именем read3.py следующим скриптом. Он прочитает файл без какого-либо файлового объекта с помощью оператора.

# Прочитать файл, используя оператор

с open ("countryList.txt") в качестве fhandler:
print (fhandler.readlines ())

Выход:

После запуска сценария появится следующий вывод.

Написание текстового файла:

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

Пример 4: Запись в файл с использованием файлового объекта

Создайте файл с именем write1.py с помощью следующего сценария. Он откроет текстовый файл для записи и напишет три строки с помощью метода write () .

# Открыть файл для записи
fileObject = open ("newfile.txt", "w")

# Добавить текст
fileObject.write ("Текст для первой строки \ n")
fileObject.write ("Текст для второй строки \ n")
fileObject. write ("Текст для третьей строки \ n")

# Закройте файл
fileObject.закрыть ()

Выход:

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

Пример 5: Запись в файл с помощью оператора

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

# Открыть файл для записи с помощью оператора

с open ("myfile.txt", 'w') как fileObj:
fileObj.write ("Первая строка \ n")
fileObj.write ("Вторая строка \ n")

Выход:

Следующий вывод появится после запуска сценария и команды «cat» для чтения файла.

Вывод:

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