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

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

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

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

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

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

This is test file

line 2

line 3

this line intentionally left lank

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

handle = open("test.

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

handle = open("test.txt")

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

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

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

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

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

 

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

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

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

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

test.txt.

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

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

data = handle.read()

print(data)

handle.close()

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

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

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

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

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

print(data)

handle.close()

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

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

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

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

print(data)

handle. close()

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

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

Telegram Чат & Канал

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

Паблик VK

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

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

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

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

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

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

 

for line in handle:

    print(line)

 

handle.close()

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

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

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

 

while True:

    data = handle.read(1024)

    print(data)

 

    if not data:

        break

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

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

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

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

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.

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

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

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

try:

    file_handler = open("test. txt")

    for line in file_handler:

        print(line)

except IOError:

    print("An IOError has occurred!")

finally:

    file_handler.close()

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

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

try:

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

    for line in file_handler:

        print(line)

except IOError:

    print("An IOError has occurred!")

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

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

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

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

E-mail: [email protected]

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

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

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

Чтение и запись в файл ~ PythonRu

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

Файлы Python

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

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

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

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

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

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

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

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

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

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

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

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

Метод open()

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

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

f = open(file_name, access_mode)

Где,

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

Пример

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

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

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

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

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

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

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

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

Метод close()

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

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

Способ №1

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

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

f.close()

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

Способ №2

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

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

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

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

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

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

Способ №3

Инструкция with

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

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

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

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

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

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

Функция read()

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

Синтаксис

file.read(size)

Где,

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

Пример

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

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

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

Функция readline()

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

Пример

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

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

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

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

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

Функция write()

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

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

Синтаксис

file.write(string)

Пример

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

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

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

Функция rename()

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

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

import os
os.rename(src,dest)

Где,

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

Пример

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

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

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

Пример

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

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

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

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

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

Файлы — Погружение в Python 3

11. Файлы

«девять миль ходьбы это не шутка, особенно во время дождя.» —Harry Kemelman, The Nine Mile Walk

На моём Windows ноутбуке было 38493 файла, прежде чем я установил одно приложение. Установка Python 3 добавила почти 3000 файлов к общему объёму. Файлы представляют собой первичную парадигму хранения информации в основных операционных системах; эта концепция настолько укоренилась, что большинство людей не воспримут нечто другое альтернативное. Образно говоря, Ваш компьютер тонет в море файлов.

11.

2 Чтение из текстовых файлов

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

a_file = open('examples/chinese.txt', encoding='utf-8')

Python имеет встроенную функцию open(), которой передается имя файла в качестве аргумента. В примере имя файла 'examples/chinese.txt' и в нём есть 5 интересных вещей:

  1. Это не просто имя файла, это комбинация пути к каталогу и имя файла. Гипотетически, в функцию открытия файла можно было бы передать два параметра: путь к файлу и имя файла, но в функцию open() можно передать только один. В Python, когда это необходимо вы можете включать все или некоторые пути к каталогу.
  2. При указании пути к каталогу используется / (прямая обратная черта, слэш, правый слэш), не обсуждая какая операционная система используется. Windows использует \ (обратную косую черту, обратный слэш, слэш влево) для указания пути к каталогам, а операционные системы Linux и MacOS используют / (прямая обратная черта, слэш, правый слэш). В Python прямой слэш просто работает всегда, даже на Windows.
  3. Путь каталога не начинается с косой черты (слэша) или буквы, это называется относительным путем. Относительно чего? Имей терпение, кузнечик!
  4. Это строки. Все современные операционные системы (включая Windows) используют Unicode для хранения имён файлов и директорий. Python 3 полностью поддерживает не-ascii пути.
  5. Файл не обязательно должен находиться на локальных дисках. Вы можете использовать сетевые диски. Этот файл может быть объектом виртуальной файловой системы (/proc в linux). Если ваш компьютер считает это за файл и даёт возможность обращаться к этому как к файлу, то Python сможет открыть этот файл.

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

11.2.1 Особенности кодировки показывают своё страшное лицо

Байты байт; символы абстракции. Строка представляет собой последовательность символов в кодировке Юникод. Но файлы на диске не являются последовательностью символов в кодировке Unicode, а являются последовательностью байтов. Если вы читаете текстовый файл с диска, то как Python преобразует эту последовательность байт в последовательность символов? Он декодирует байт по определенному алгоритму кодировки и возвращает последовательность символов в кодировке Unicode (т. е. в виде строки).

>> file = open('examples/chinese.txt')
…>>> a_string = file.read()
…Traceback (most recent call last):
… File «<stdin>», line 1, in <module>
… File «C:\Python31\lib\encodings\cp1252.py», line 23, in decode
… return codecs.charmap_decode(input, self.errors, decoding_table)[0]
…UnicodeDecodeError: 'charmap' codec can’t decode byte 0x8f in position 28: character maps to <undefined>
 
[[Категория:Погружение в Python 3]]

Python открытие файла и превращение его в список



Я пытаюсь открыть файл, а затем взять этот файл и превратить его в список, я немного теряюсь в том, как получить его в список, я знаю, что могу открыть файл с open(), но я не хочу использовать read. line

Входные данные (build1,200), (build2, 267) все в txt-файле, который нужно открыть

Выход

Корпус 1, 200

Build2, 200

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

python
Поделиться Источник Andrew3943     09 марта 2015 в 21:14

2 ответа


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

    Вопрос: Как я могу открыть файл в python, который содержит одно целое значение на строку. Заставить python прочитать файл, сохранить данные в списке, а затем распечатать список? Я должен спросить у пользователя имя файла, а затем сделать все вышеописанное. Файл, введенный пользователем, будет...

  • Python, открытие файла, чтение файла, редактирование файла и чтение строки файла?

    Поэтому я предполагаю открыть текстовый файл с помощью >>>yyy('yyy.txt') и после ввода этого python должен найти мой файл (что и делает, так как находится в том же каталоге) и отредактировать все слова 'hot' в новое слово 'why not'. после редактирования текстового файла содержимое всего файла...



1

Это поместит каждую строку в отдельные подсписки в списке 2d:

sav = []
with open("filename", "r") as fileopen:
    for line in fileopen:
        sav.append(line.split())

Я предполагаю, что вы используете файл .txt .

Поделиться zeldor     09 марта 2015 в 21:23



0

В основном это будет последовательность с именем 'tup'. Что делает open(), так это открывает файл. Двумя аргументами, которые вы передадите, будут 'filename' и то, что вы хотите сделать с содержимым файла. Filename будет представлять собой весь каталог файла, то есть "C:/User...../file.txt". То, что 'r' означает, - это только файл 'read'. tuple() создаст последовательность данных из вашего файла, которая будет неизменной (вы не можете изменить ее), но вы можете получить доступ к данным внутри нее.

    tup=tuple(open(file,'r'))  

Поделиться Rogue     09 марта 2015 в 22:59


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


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

У меня возникли проблемы с чтением текстового файла в список, что у меня есть на данный момент: lines = open ('dracula.txt', 'r'). readlines () где dracula.txt-это текстовый файл в том же каталоге,...


открытие файла переменной в python

Я пытаюсь создать программу, которая включает в себя открытие пользователем файла в python. Вот соответствующий код: def fileopen(): source = input(Enter the name of the source file (w/ extension):...


Как контролировать открытие и загрузку файла?

Я использую Laravel 5.2. Как контролировать открытие и загрузку файла? Подобный этому: xxx.php?filename=0001.jpg Иногда браузер покажет изображение, а иногда покажет окно загрузки файла ?Как его...


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

Вопрос: Как я могу открыть файл в python, который содержит одно целое значение на строку. Заставить python прочитать файл, сохранить данные в списке, а затем распечатать список? Я должен спросить у...


Python, открытие файла, чтение файла, редактирование файла и чтение строки файла?

Поэтому я предполагаю открыть текстовый файл с помощью >>>yyy('yyy.txt') и после ввода этого python должен найти мой файл (что и делает, так как находится в том же каталоге) и отредактировать все...


Превращение списка из текстового файла в список python

Я учу класс, и я хочу, чтобы они прочитали список из 10 слов из текстового файла, а затем случайным образом отобразили 9 из них в сетке 3 на 3. Мои мысли были таковы: 1) Прочитайте текстовый файл с...


python превращение поля поплавков input в правильно разделенный список чисел

Я работаю над приложением flask, где мне нужно, чтобы пользователи input составляли список чисел, которые будут плавающими. У меня есть текущий метод, который выглядит так: times =...


Превращение списка 2D в список 1D в python

Превращение списка 2D в список 1D в python.


Может ли открытие файла .py в PyCharm быть harmful/malicious?

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


Python-запретить открытие файла в определенном формате

есть ли какой-нибудь способ im Python предотвратить открытие файла Пользователем в формате .pdf во время выполнения кода? Мой код открывает / сохраняет несколько файлов в цикле, и открытие нового...

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



Я хочу открыть файл для записи.

with open(oname.text , 'w') as f:

а теперь я хочу записать файлы в папку "Playlist"

Я знаю, что должен использовать os.path , но я не знаю, как его использовать

ты все

python text copy directory
Поделиться Источник kibaya     15 января 2015 в 05:25

3 ответа


  • Определение типа файла в папке assets

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

  • Запустите скрипт Python для каждого текстового файла в папке

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



1

path = os.path.join('Playlist', oname.text)
with open(path, 'w') as f:
    ...

Если вы не уверены, что поддир 'Playlist' текущего каталога уже существует, добавьте к нему префикс:

if not os.path.isdir('Playlist'):
    if os.path.exists('Playlist'):
        raise RuntimeError('Playlist exists and is a file, now what?!')
    os.mkdir('Playlist')

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

Используйте os.makedirs вместо os.mkdir , если путь, который вы хотите, имеет несколько уровней каталогов, например Play/List/Whatever (вы можете использовать его в любом случае на всякий случай).

Поделиться Alex Martelli     15 января 2015 в 05:30



0

Вы можете изменить текущий рабочий каталог с помощью функции os.chdir .

os.chdir('Playlist')
with open(oname.text , 'w') as f:
    ...

Поделиться Avinash Raj     15 января 2015 в 05:33



0

Используйте оператор with и метод os.path.join

dir_path =  "/home/Playlist"
file_path = os.path.join('dir_path, "oname.txt")
content = """ Some content..."""
with open(file_path, 'wb') as fp:
    fp.write(content)

OR

fp = open(file_path, "wb"):
fp.write(content)
fp.close()

Поделиться Vivek Sable     15 января 2015 в 05:36



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


Открытие файла в папке pwdir в Python-Applescript годах

Открытие файла, доступного в папке temp текущего рабочего каталога в python Я пытался pwdir=os.getcwd() tempdir=pwdir+/temp/test.txt f=open(tempdir,'r+') Когда я печатаю путь tempdir, он...


Открытие файла XML, расположенного в папке addin

В VSTO Excel добавить код: Dim XMLDoc As XElement = XElement.Load(XMLFile1.xml) генерирует ошибку FileNotFound с сообщением ( не удалось найти файл 'C:\Users\doug\Documents\XMLFile1.xml'. ) он ищет...


открытие файла переменной в python

Я пытаюсь создать программу, которая включает в себя открытие пользователем файла в python. Вот соответствующий код: def fileopen(): source = input(Enter the name of the source file (w/ extension):...


Определение типа файла в папке assets

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


Запустите скрипт Python для каждого текстового файла в папке

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


Python, открытие файла, чтение файла, редактирование файла и чтение строки файла?

Поэтому я предполагаю открыть текстовый файл с помощью >>>yyy('yyy.txt') и после ввода этого python должен найти мой файл (что и делает, так как находится в том же каталоге) и отредактировать все...


поиск файла, содержащего подстроку в папке, python?

Предположим, что путь c:\users\test, папка test содержит много файлов. я хочу найти файл в тестовой папке, имя файла которого содержит слово postfix в скрипте python. Кто-нибудь может мне помочь?


Открытие файла в Python дает мне ошибки

Я совсем новичок в Python, и у меня возникли проблемы с открытием файла в Python. Я хочу открыть текстовый файл с именем 'coolStuff' в папке на моем рабочем столе, и именно так я набираю команду, но...


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

У меня есть файл tkinter python, сохраненный в папке в каталоге. Значки и другие ресурсы, предназначенные для этого файла, сохраняются в другой папке. root_directory | |---resources | | |...


Python-запретить открытие файла в определенном формате

есть ли какой-нибудь способ im Python предотвратить открытие файла Пользователем в формате .pdf во время выполнения кода? Мой код открывает / сохраняет несколько файлов в цикле, и открытие нового...

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

Обзор

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

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

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

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

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

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

Типы файлов

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

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

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

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

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

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

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

Функция открытия ()

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

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

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

Для обучения Python наша главная рекомендация - DataCamp.

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

Синтаксис для открытия файлового объекта в Python:

    файл_   объект   =   открытый (  «  имя файла  »  ,   «  режим  »  )  объект - переменная 

09

, где 9000object - это переменная. для добавления файлового объекта.

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

Режим

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

Режимы:

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

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

    F = открытый («рабочий файл», «w»)  
   Печать f    

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

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

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

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

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

Однако для целей этого руководства мы будем называть новый файл «testfile.txt».

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

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

    file = open («testfile.txt», «w»)  
    
   file.write («Привет, мир»)  
   file.write («Это наш новый текстовый файл»)  
   file.write («а это еще одна строка.»)  
   файлов.напишите («Почему? Потому что мы можем»)  
    
   file.close ()    

Естественно, если вы откроете текстовый файл - или посмотрите на него - с помощью Python, вы увидите только текст, который мы сказали интерпретатору добавить. Выше мы не добавляли символы новой строки, но вы, безусловно, можете использовать «\ n» для форматирования файла при просмотре.

    $ cat testfile.txt  
   Привет, мир  
   Это наш новый текстовый файл  
   а это другая линия. 
   Почему? Потому что мы     можем.  
  

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

На самом деле существует несколько способов чтения текстового файла в Python, а не только один.

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

    file.read ()    

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

    файл =   открытый (   тестовый файл.txt   ,    r   ”)  
   распечатать   файл. Прочитать   ()    

Убедитесь, что у вас правильный путь к файлу, будь то относительный путь или абсолютный путь, иначе ваша программа python не сможет открыть файл. Результат этой команды будет отображать весь текст внутри файла, тот же текст, который мы сказали интерпретатору добавить ранее. Нет необходимости переписывать все это заново, но если вам нужно знать, будет показано все, кроме «$ cat testfile.txt ».

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

Например, с помощью следующего кода интерпретатор прочитает первые пять символов сохраненных данных и вернет их в виде строки:

    файл =   открытый (  «testfile.txt», «r»)

   напечатать   файл. Прочитать   (5)      

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

Результат будет выглядеть так:

    Привет    

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

Зачем вам использовать что-то подобное?

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

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

    файл =   открытый (   testfile.txt   ,    r   )  
   печать   file.readline   ():    

Это вернет первую строку файла, например:

    Привет, мир    

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

    файл =   открытый (   тестовый файл.txt   ,    r   )  
   печать   file.readline   (3):    

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

    f   ile =   open (   testfile.txt   ,    r   )  
   p   rint   file.readlines   ()    

В результате вы получите:

    [«Hello World», «Это наш новый текстовый файл», «и это еще одна строка». «Почему? Потому что мы можем. »]    

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

Цикл по файловому объекту

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

    f   ile =   open (   testfile.txt   ,    r   )  
   f   или строка в файле:  
   p   линия обтекания,    

Это вернет:

    Привет, мир  
   Это наш новый текстовый файл  
   а это другая линия.  
   Почему? Потому что мы можем.    

Видите, насколько это проще предыдущих методов?

Использование метода записи в файл

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

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

    f   ile =   открыто (  «testfile.txt», «w»)
 
  f   ile.write   («Это тест») 
  f   ile.write   («Чтобы добавить больше строк.»)
 
  f   ile.close   ()    

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

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

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

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

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

Обработка файлов в Python

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

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

    fh   =   open (  «привет.txt »,« r »)    

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

    Fh   =   открыто (  «hello.txt», «r»)  
   печать   fh.read   ()    

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

    fh   =   открыто (  «  hello.text  », «r»)  
   печать   fh.readline   ()    

Чтобы прочитать список строк в текстовом файле:

    fh   =   открыто (  «hello.txt», «r»)  
   печать   fh.readlines   ()    

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

    fh   =   открыто (  «hello.txt», «w»)  
  
   fh.напишите    Поместите сюда текст  , который вы хотите добавить»)  
   fh.write   («и больше строк, если необходимо»)  
  
   fh.close   ()    

Вы также можете использовать это для одновременной записи нескольких строк в файл (пример новой строки python):

    f   h   = открытый («  hello.txt»  , «w  »)  
   l   ines_of_text   = [«Одна строка текста здесь \ n», «и еще одна строка здесь \ n», «и еще одна здесь \ n», «и так далее и тому подобное»]  
   ж   ч.Линии записи   (  строк_текста  )  
   f   h. Закрыть   ()    

Чтобы добавить файл:

    fh   =   открыто (  «hello.txt», «a»)  
   fh.write   («Мы снова встретимся, мир»)  
   fh.close    

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

    f   h   =   открыто (  «привет.txt »,« r »)  
   p   rint   fh.read   ()  
   f   h. Закрыть   ()    

с заявлением

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

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

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

    с открытым («имя файла») как файл:    

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

    w   с открытым («testfile.txt») как файл:  
   d   ata =   файл. Читать   ()  
   d   или что-то с данными    

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

   w  с открытым («testfile.txt») как f:  
   f   или строка в f:  
   p   линия обтекания,    

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

Использование оператора With в Python

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

Для записи в файл с помощью оператора with:

    с   открытыми (  «hello.txt», «w») как f:  
   f.write   («Привет, мир»)    

Чтобы прочитать файл построчно, выведите в список:

    w   с открытым («hello.txt») как f:  
   d   ata =   f.readlines   ()    

Это займет весь текст или содержимое из «hello.txt »и сохраните его в строке с именем« data ».

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

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

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

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

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

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

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

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

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

Больше чтения

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

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

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

Для обучения Python наша главная рекомендация - DataCamp.

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

Файлы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  попробуйте:
   f = open ("test.txt ", кодировка = 'utf-8')
   # выполнять файловые операции
наконец-то:
   f.close ()  

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

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

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

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

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

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

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

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

  с open ("test.txt", 'w', encoding = 'utf-8') как f:
   f.write ("мой первый файл \ n")
   f.write ("Этот файл \ n \ n")
   f.write ("содержит три строки \ n")  

Эта программа создаст новый файл с именем test.txt в текущем каталоге, если он не существует. Если он существует, он перезаписывается.

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


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

Чтобы прочитать файл на Python, мы должны открыть файл в режиме чтения r .

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

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

  >>> f = open ("test.txt", 'r', encoding = 'utf-8')
>>> f.read (4) # читать первые 4 данных
'Этот'

>>> f.read (4) # читать следующие 4 данные
' является '

>>> f.read () # читать остаток до конца файла
'мой первый файл \ nЭтот файл \ nсодержит три строки \ n'

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

Мы видим, что метод read () возвращает новую строку как '\ n' .По достижении конца файла при дальнейшем чтении мы получаем пустую строку.

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

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

>>> f.seek (0) # переводим файловый курсор в исходную позицию
0

>>> print (f.read ()) # читать весь файл
Это мой первый файл
Этот файл
содержит три строки  

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

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

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

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

  >>> f.readline ()
'Это мой первый файл \ n'

>>> f.readline ()
'Этот файл \ n'

>>> f.readline ()
'содержит три строки \ n'

>>> f.readline ()
' 

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

  >>> ф.readlines ()
['Это мой первый файл \ n', 'Этот файл \ n', 'содержит три строки \ n']  

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

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

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

Метод Описание
закрыть () Закрывает открытый файл. Не действует, если файл уже закрыт.
отсоединить () Отделяет базовый двоичный буфер от TextIOBase и возвращает его.
fileno () Возвращает целое число (дескриптор файла) файла.
заподлицо () Очищает буфер записи файлового потока.
isatty () Возвращает Истина , если файловый поток является интерактивным.
читать ( n ) Читает из файла не более n символа.Читает до конца файла, если он отрицательный или Нет .
читаемый () Возвращает Истинно , если файловый поток может быть прочитан.
строка чтения ( n = -1) Читает и возвращает одну строку из файла. Считывает не более n байта, если указано.
строки чтения ( n = -1) Читает и возвращает список строк из файла. Считывает не более n байтов / символов, если указано.
поиск ( смещение , от = SEEK_SET ) Изменяет позицию файла на , смещение байта, по отношению к с (начало, текущее, конец).
для поиска () Возвращает Истинно , если файловый поток поддерживает произвольный доступ.
сказать () Возвращает текущее местоположение файла.
усечь ( размер = Нет ) Изменяет размер файлового потока до , размер байта.Если размер не указан, изменяется до текущего местоположения.
с возможностью записи () Возвращает Истина , если возможна запись в файловый поток.
запись ( с ) Записывает строку s в файл и возвращает количество записанных символов.
телефонных линий ( строка ) Записывает в файл список из строки .

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

7.1.2. Метод String format ()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

7.1.3. Ручное форматирование строки

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

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

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

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

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

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

59'.zfill (5) "3.1415

59"

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

json

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

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

Примечание

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

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

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

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

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

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

См. Также

pickle - модуль pickle

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

Как эффективно читать текстовый файл в Python

Резюме : в этом руководстве вы узнаете различные способы чтения текстовых файлов в Python.

TL; DR

Ниже показано, как прочитать все тексты из файла readme.txt в строку:

 

с open ('readme.txt') как f: lines = f.readlines ()

Язык кода: JavaScript (javascript)

Шаги для чтения текстового файла в Python

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

  • Сначала откройте текстовый файл для чтения с помощью функции open () .
  • Во-вторых, прочтите текст из текстового файла с помощью метода файлового объекта read () , readline () или readlines () .
  • В-третьих, закройте файл с помощью метода file close () .

1) функция open ()

Функция open () имеет много параметров, но вы сосредоточитесь на первых двух.

 

open (path_to_file, mode)

Параметр path_to_file указывает путь к текстовому файлу.

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

Чтобы указать путь к файлу, используйте косую черту ( '/' ), даже если вы работаете в Windows.

Например, если файл readme.txt хранится в папке с образцом в качестве программы, вам необходимо указать путь к файлу как c: /sample/readme.txt

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

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

Режим Описание
'r' Открыть текстовый файл для чтения текста
' Открыть текстовый файл для ввода текста
' a ' Открыть текстовый файл для добавления текста

Например, чтобы открыть файл с именем the-zen-of -python.txt , хранящийся в той же папке, что и программа, вы используете следующий код:

 

f = open ('the-zen-of-python.txt', 'r')

Язык кода: JavaScript (javascript )

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

2) Методы чтения текста

Файловый объект предоставляет вам три метода чтения текста из текстового файла:

  • read () - прочитать весь текст из файла в строку.Этот метод полезен, если у вас есть небольшой файл, и вы хотите управлять всем текстом этого файла.
  • readline () - читать текстовый файл построчно и возвращать все строки как строки.
  • readlines () - прочитать все строки текстового файла и вернуть их в виде списка строк.

3) метод close ()

Файл, который вы открываете, останется открытым, пока вы не закроете его с помощью метода close ().

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

Ниже показано, как вызвать метод close () для закрытия файла:

 

f.close ()

Язык кода: CSS (css)

Чтобы закрыть файл автоматически без вызова close () , вы используете с оператором следующим образом:

 

с open (path_to_file) как f: content = f.readlines ()

Язык кода: JavaScript (javascript)

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

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

Мы будем использовать файл-zen-of-python.txt для демонстрации.

В следующем примере показано, как использовать метод read () для чтения всего содержимого файла the-zen-of-python.txt в строку:

 

с open ('the-zen -of-python.txt ') как f: content = f.read () print (содержание)

Язык кода: JavaScript (javascript)

Вывод:

 

Красивое лучше уродливого.Явное лучше, чем неявное. Лучше простое, чем сложное. ...

В следующем примере используется метод readlines () для чтения текстового файла и возврата содержимого файла в виде списка строк:

 

lines = [] с open ('the-zen-of-python.txt') как f: lines = f.readlines () count = 0 для строки в строках: count + = 1 print (f'line {count}: {line} ')

Язык кода: JavaScript (javascript)

Вывод:

 

строка 1: Красивое лучше, чем уродливое.строка 2: Явное лучше, чем неявное. строка 3: Простое лучше, чем сложное. ...

В следующем примере показано, как использовать readline () для чтения текстового файла построчно:

 

с open ('the-zen-of-python.txt') как f: line = f.readline () а строка: line = f.readline () print (строка)

Язык кода: JavaScript (javascript)

Вывод:

 

Явное лучше, чем неявное.Лучше простое, чем сложное. Сложный лучше, чем сложный. ...

Более лаконичный способ чтения текстового файла построчно

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

 

с open ('the-zen-of-python.txt') как f: для строки в f: print (line)

Язык кода: JavaScript (javascript)

Это более лаконичный способ чтения текстового файла построчно.

Чтение текстовых файлов UTF-8

Код в предыдущих примерах отлично работает с текстовыми файлами ASCII. Однако, если вы работаете с другими языками, такими как японский, китайский и корейский, текстовый файл не является простым текстовым файлом ASCII. И, скорее всего, это файл UTF-8, в котором используются не только стандартные текстовые символы ASCII.

Чтобы открыть текстовый файл UTF-8, вам необходимо передать encoding = 'utf-8' в функцию open () , чтобы она ожидала от файла символы UTF-8.

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

Ниже показано, как пройти через файл quotes.txt :

 

с open ('quotes.txt', encoding = 'utf8') как f: для строки в f: печать (line.strip ())

Язык кода: JavaScript (javascript)

Вывод:

Сводка

  • Используйте функцию open () с режимом 'r' , чтобы открыть текстовый файл для чтения.
  • Используйте метод read () , readline () или readlines () для чтения текстового файла.
  • Всегда закрывайте файл после завершения чтения с помощью метода close () или с оператором .
  • Используйте кодировку encoding = 'utf-8' для чтения текстового файла UTF-8.

Вы нашли это руководство полезным?

Как открывать файлы в 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 File Output

По умолчанию метод 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 для вас и меня 0.4.beta1

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

Открытие дела

Чтобы открыть файл, мы используем функцию open () . Для этого требуются два аргумента: первый - путь к файлу или имя файла, а второй - режим, который он должен открыть. Режимы вроде

  • «r» -> открыть только для чтения, вы можете читать файл, но не можете редактировать / удалять что-либо внутри
  • «w» -> открыть с возможностью записи, означает, что если файл существует, удалите все содержимое и откройте его для записи
  • «a» -> открыть в режиме добавления

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

 >>> fobj = open ("love.txt")
>>> fobj
<_io.TextIOWrapper name = 'love.txt' mode = 'r' encoding = 'UTF-8'>
 

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

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

 >>> fobj = open ("love.txt")
>>> fobj
<_io.TextIOWrapper name = 'love.txt' mode = 'r' encoding = 'UTF-8'>
>>> fobj.close ()
 

Важно

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

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

Чтение файла

Для одновременного чтения всего файла используйте метод read () .

 >>> fobj = open ("sample.txt")
>>> fobj.read ()
'Я люблю Python \ nPradeepto любит KDE \ nСанкаршан любит Openoffice \ n'
 

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

 >>> fobj = open ("sample.txt")
>>> fobj.readline ()
'Я люблю Python \ n'
>>> fobj.readline ()
"Прадипто любит KDE \ n"
 

Чтобы прочитать все строки в списке, мы используем метод readlines () .

 >>> fobj = open ("sample.txt")
>>> fobj.readlines ()
['Я люблю Python \ n', 'Прадипто любит KDE \ n', 'Санкаршан любит Openoffice \ n']
 

Вы можете даже перебирать строки в файловом объекте.

 >>> fobj = open ("sample.txt")
>>> для x в fobj:
... печать (х, конец = '')
...
Я люблю Python
Прадепто любит KDE
Санкаршан любит Openoffice
 

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

 #! / Usr / bin / env python3
name = input ("Введите имя файла:")
fobj = open (имя)
печать (fobj.read ())
fobj.close ()
 

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

Выход

 $ ./showfile.py
Введите имя файла: образец.текст
Я люблю Python
Прадепто любит KDE
Санкаршан любит Openoffice
 

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

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

 >>> с open ('setup.py') как fobj:
... для строки в fobj:
... строка печати,
...
#! / usr / bin / env python3
"" "Факторный проект" ""
из setuptools импортируйте find_packages, настройте

настройка (имя = 'факториал',
    версия = '0,1',
    description = "Факторный модуль.",
    long_description = "Тестовый модуль для нашей книги.",
    платформы = ["Linux"],
    author = "Кушал Дас",
    author_email = "[email protected]",
    url = "https://pymbook.readthedocs.io/en/latest/",
    license = "http://www.gnu.org/copyleft/gpl.html",
    пакеты = find_packages ()
    )
 

Запись в файл

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

 >>> fobj = open ("ircnicks.txt", 'w')
>>> fobj.write ('powerpork \ n')
>>> fobj.write ('индраг \ п')
>>> fobj.write ('мишти \ п')
>>> fobj.write ('санкаршан')
>>> print ("Это последняя строка.", file = fobj)
>>> fobj.close ()
 

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

 >>> fobj = open ('ircnicks.txt')
>>> s = fobj.read ()
>>> печать (и)
powerpork
индраг
мишти
Санкаршан
Это последняя строчка.

copyfile.py

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

 #! / Usr / bin / env python3
import sys
если len (sys.argv) <3:
    print («Неверный параметр»)
    print ("./ copyfile.py файл1 файл2")
    sys.exit (1)
с open (sys.argv [1]) как f1:
    s = f1.read ()
с open (sys.argv [2], 'w') как f2:
    f2.write (s)
 

Примечание

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

Как видите, здесь мы использовали новый модуль sys . sys.argv содержит все параметры командной строки. Помните команду cp в оболочке, после cp мы вводим сначала файл, который нужно скопировать, а затем новое имя файла.

Первое значение в sys.argv - это имя самой команды.

 #! / Usr / bin / env python3
import sys
print ("Первое значение", sys.argv [0])
print ("Все значения")
для i, x в перечислении (sys.argv):
    печать (я, х)
 

Выход

 $ ./argvtest.py Привет!
Первое значение ./argvtest.py
Все ценности
0 ./argvtest.py
1 привет
2 там
 

Здесь мы использовали новую функцию enumerate (iterableobject) , которая возвращает номер индекса и значение из итерируемого объекта.

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

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

 #! / Usr / bin / env python3

импорт ОС
import sys


def parse_file (путь):
    "" "
    Анализирует текстовый файл по заданному пути и возвращает пробел, табуляцию и новую строку
    подробности.

    : arg path: Путь к текстовому файлу для синтаксического анализа

    : return: Кортеж с количеством пробелов, табуляции и строк.
    "" "
    fd = open (путь)
    я = 0
    пробелы = 0
    вкладки = 0
    для i строка в enumerate (fd):
        пробелы + = line.count ('')
        вкладки + = line.count ('\ t')
    # Теперь закройте открытый файл
    fd.close ()

    # Возвращаем результат в виде кортежа
    возвращаемые пробелы, табуляции, i + 1

def main (путь):
    "" "
    Функция, которая выводит количество пробелов, табуляции и строк в файле.: arg path: Путь к текстовому файлу для синтаксического анализа
    : return: Истина, если файл закрывается, или Ложь.
    "" "
    если os.path.exists (путь):
        пробелы, табуляции, строки = parse_file (путь)
        print ("Пробелы% d. табуляции% d. строки% d"% (пробелы, табуляции, строки))
        вернуть True
    еще:
        вернуть ложь


если __name__ == '__main__':
    если len (sys.argv)> 1:
        основной (sys.argv [1])
    еще:
        sys.exit (-1)
    sys.exit (0)
 

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

Давайте напишем реальный код

Знаете ли вы, сколько процессоров в вашем процессоре? или как называется модель? Давайте напишем код, который поможет нам узнать эти вещи.

Если вы работаете в Linux, вы можете сначала просмотреть вывод команды lscpu . Фактически вы можете найти информацию в файле, расположенном по адресу / proc / cpuinfo .

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

Подсказка

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

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

Обработка файлов Python. Как создавать, читать, обновлять и удалять… | by Woz

Предположим, у нас есть демофайл .txt , находится в той же папке, что и Python:

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

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

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

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

Прочитать полное содержимое файла в виде строки

 f = open ("subtitles.txt", "r") type (f) # f - файловый объект: _io.TextIOWrapper 
data = f.read () print (data) type (data) # тип данных: strf.close ()

Чтение только нескольких символов файла

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

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

Метод readline (): читает только одну строку файла:

 f = open ("demofile.txt", "r") 
print (f.readline ())
f.close ()
Метод

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

По умолчанию функция readlines () читает до конца файла и возвращает список , содержащий каждую строку в файле как элемент списка.

 f = open ("demofile.txt", "r") 
line_list = f.readlines () type (line_list) # listprint (line_list)
f.close ()

Затем вы можете вывести первые несколько строк, нарезав список

 f = open ("demofile.txt", "r") 
line_list = f.readlines () Top_5_lines = line_list [0: 5]
print (Top_5_lines)
f.close ()

Распечатать каждую строку в списке

 f = open ('demofile.txt', 'r +') 
для строки в f.readlines ():
print line
f. close ()

fileObject.readlines (n)

Здесь n - номер подсказки, который используется для ограничения вывода.

Если количество возвращенных байтов превышает количество подсказок, не будет возвращено больше строк .Значение по умолчанию -1, что означает, что будут возвращены все строки.

Синтаксис:

 fileObject.readlines (n) 

Примечание : n - это количество символов, а не количество строк.

Оставить комментарий

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

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

© 2019 Штирлиц Сеть печатных салонов в Перми

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