Содержание

Файлы. Работа с файлами. | 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. Чтение и запись в файл ~ 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 – это очень просто. Начнем же.

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

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?

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

Открыть форум

> Чат и Паблик Программистов

Присоединяйтесь к нашему чату в Телеграм и подпишитесь на наш паблик в ВК.

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

создание, изменение, удалений файлов ~ PythonRu

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

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

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

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

Вывод текущей директории

Для получения текущего рабочего каталога используется os.getcwd():

import os


print("Текущая деректория:", os.getcwd())

os.getcwd() возвращает строку в Юникоде, представляющую текущий рабочий каталог. Вот пример вывода:

Текущая деректория: C:\python3\bin

Создание папки

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


os.mkdir("folder")

После ее выполнения в текущем рабочем каталоге тут же появится новая папка с названием «folder».

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



if not os.path.isdir("folder"):
     os.mkdir("folder")

Функция os.path.isdir() вернет True, если переданное имя ссылается на существующий каталог.

Изменение директории

Менять директории довольно просто. Проделаем это с только что созданным:


os.chdir("folder")

Еще раз выведем рабочий каталог:


print("Текущая директория изменилась на folder:", os.getcwd())

Вывод:

Текущая директория изменилась на folder: C:\python3\bin\folder

Создание вложенных папок

Предположим, вы хотите создать не только одну папку, но и несколько вложенных:


os.chdir("..")


os.makedirs("nested1/nested2/nested3")

Это создаст три папки рекурсивно, как показано на следующем изображении:

Создание вложенных папокСоздание вложенных папок

Создание файлов

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


text_file = open("text.txt", "w")

text_file.write("Это текстовый файл")

w значит write (запись), a — это appending (добавление данных к уже существующему файлу), а r — reading (чтение). Больше о режимах открытия можно почитать здесь.

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

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


os.rename("text.txt", "renamed-text.txt")

Функция os.rename() принимает 2 аргумента: имя файла или папки, которые нужно переименовать и новое имя.

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

Функцию os.replace() можно использовать для перемещения файлов или каталогов:


os.replace("renamed-text.txt", "folder/renamed-text.txt")

Стоит обратить внимание, что это перезапишет путь, поэтому если в папке folder уже есть файл с таким же именем (renamed-text.txt), он будет перезаписан.

Список файлов и директорий


print("Все папки и файлы:", os.listdir())

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

Все папки и файлы: ['folder', 'handling-files', 'nested1', 'text.txt']

А что если нужно узнать состав и этих папок тоже? Для этого нужно использовать функцию os.walk():


for dirpath, dirnames, filenames in os.walk("."):
    
    for dirname in dirnames:
        print("Каталог:", os.path.join(dirpath, dirname))
    
    for filename in filenames:
        print("Файл:", os.path.join(dirpath, filename))

os.walk() — это генератор дерева каталогов. Он будет перебирать все переданные составляющие. Здесь в качестве аргумента передано значение «.», которое обозначает верхушку дерева:

Каталог: .\folder
Каталог: .\handling-files
Каталог: .\nested1
Файл: .\text.txt
Файл: .\handling-files\listing_files.py
Файл: .\handling-files\README.md
Каталог: .\nested1\nested2
Каталог: .\nested1\nested2\nested3

Метод os.path.join() был использован для объединения текущего пути с именем файла/папки.

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

Удалим созданный файл:


os.remove("folder/renamed-text.txt")

os.remove() удалит файл с указанным именем (не каталог).

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

С помощью функции os.rmdir() можно удалить указанную папку:


os.rmdir("folder")

Для удаления каталогов рекурсивно необходимо использовать os.removedirs():


os.removedirs("nested1/nested2/nested3")

Это удалит только пустые каталоги.

Получение информации о файлах

Для получения информации о файле в ОС используется функция os.stat(), которая выполняет системный вызов stat() по выбранному пути:

open("text.txt", "w").write("Это текстовый файл")


print(os.stat("text.txt"))

Вывод:

os.stat_result(st_mode=33206, st_ino=14355223812608232, st_dev=1558443184, st_nlink=1, st_uid=0, st_gid=0, st_size=19, st_atime=1575967618, st_mtime=1575967618, st_ctime=1575966941)

Это вернет кортеж с отдельными метриками. В их числе есть следующие:

    • st_size — размер файла в байтах
    • st_atime — время последнего доступа в секундах (временная метка)
    • st_mtime — время последнего изменения
    • st_ctime — в Windows это время создания файла, а в Linux — последнего изменения метаданных

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


print("Размер файла:", os.stat("text.txt").st_size)

Вывод:

Размер файла: 19

На этой странице больше об атрибутах.

Выводы

Работать с файлами и каталогами в Python очень просто. Не имеет значения даже используемая операционная система, хотя отдельные уникальные для системы функции можно использовать: например, os.chown() или os.chmod() в Linux. Более подробно эта тема освещена в официальной документации Python.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

‘r’ – чтение.

‘w’ – запись.

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

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

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

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

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

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

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

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

Чтение:

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

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

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

  cat my_file | python test.py

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

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

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

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

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

  seek(offset[, whence])

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

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

Пример:

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

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

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

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

  file.readline()

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

  file.readlines()

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

  file.writelines()

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

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

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

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

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

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

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

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

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

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

7. Итерация

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

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

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

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

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

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

8. Pickling

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

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

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

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

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

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

   pack(format, value1, value2 ...)

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

   unpack(format, string)

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

   calcsize(format)

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

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

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

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

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

  < - little-endian
  > - big-endian

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

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

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

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

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

import os
cwd = os.getcwd()
print cwd

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

  os.path.exists('my_file')

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

  os.listdir(path)

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

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

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

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

report = dtstat('.')
print report

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

import os, sys, fnmatch

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

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

Заключение

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

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

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

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

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

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

Многим из нас знакома ситуация, когда компьютер оказывался завален тоннами беспорядочных файлов. Только что вы открывали большой zip-архив, спустя мгновение – файлы повсюду в этой директории, вперемешку с важными документами. Наверняка приходилось мучительно скучно сортировать эту свалку вручную? Чтобы облегчить подобные задачи, мы сейчас погрузимся в «умную» работу с файлами при помощи Python.

«Работай умнее, а не усерднее». Карл Баркс

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

Генератор случайных файлов

Создадим папку ManageFiles, а внутри нее еще одну — RandomFiles. Дерево каталогов теперь должно выглядеть вот так:

ManageFiles/
 |
 |_RandomFiles/

Чтобы поиграться с файлами, мы сгенерируем их случайным образом в директории RandomFiles. Создайте файл create_random_files.py в папке ManageFiles. Вот что должно получиться:

ManageFiles/
 |
 |_ create_random_files.py
 |_RandomFiles/

Готово? Теперь поместите в файл следующий код, и перейдем к его рассмотрению:

import os
from pathlib import Path
import random

list_of_extensions = ['.rst', '.txt', '.md', '.docx', '.odt', '.html', '.ppt', '.doc']

# перейти в папку RandomFiles
os.chdir('./RandomFiles')

for item in list_of_extensions:
    # создать 20 случайных файлов для каждого расширения имени
    for num in range(20):
        # пусть имя файла начинается со случайного числа от 1 до 50
        file_name = random.randint(1, 50)
        file_to_create = str(file_name) + item
        Path(file_to_create).touch()

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

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

Далее мы переходим в папку RandomFiles и запускаем цикл. В нем мы просто говорим: возьми каждый элемент list_of_extensions и сделай с ним кое-что во внутреннем цикле 20 раз.

Теперь пришло время для импортированной функции random. Используем ее для производства случайных чисел от 1 до 50. Это просто не очень творческий способ побыстрее дать названия нашим тестовым файлам: к сгенерированному числу добавим расширение файла и получим что-то вроде 23.txt или 14.txt. И так 20 раз для каждого расширения. В итоге образуется беспорядок, достаточный для того, чтобы его было лень сортировать вручную.

Итак, запустим наш генератор хаоса через терминал.

python create_random_files.py

Поздравляю, теперь у нас полная папка неразберихи. Будем распутывать.

В той же директории, где create_random_files.py, создадим файл clean_up.py и поместим туда следующий код.

Способ 1

import os
import shutil
import glob

# перейти в папку RandomFiles
os.chdir('./RandomFiles')

# получить список файлов в папке RandomFiles
files_to_group = []
for random_file in os.listdir('.'):
    files_to_group.append(random_file)

# получить все расширения имен всех файлов
file_extensions = []
for our_file in files_to_group:
    file_extensions.append(os.path.splitext(our_file)[1])

print(set(file_extensions))

file_types = set(file_extensions)

for type in file_types:
    new_directory = type.replace(".", " ")
    os.mkdir(new_directory)  # создать папку с именем данного расширения

    for fname in glob.glob(f'*.{type[1:]}'):
        shutil.move(fname, new_directory)

Для этого импортируем еще две библиотеки: shutil и glob. Первая поможет перемещать файлы, а вторая – находить и систематизировать. Но обо всем по порядку.

Для начала получим список всех файлов в директории.

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

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

Обратите внимание на разделение строки:

os.path.splitext(our_file)[1]

Сейчас наша переменная our_file выглядит как-нибудь так: 5.docx. Когда разделим ее, получим следующее:

`('5', '.docx')`

Мы возьмем отсюда второй элемент по индексу [1], то есть .docx. Ведь по индексу [0] у нас располагается 5.

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

# создать множество и присвоить его переменной
file_types = set(file_extensions)

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

Поэтому, итерируя по нашему множеству, мы заменяем точку на пустую строку. И создаем папку с полученным названием.

new_directory = type.replace(".", " ")
# наша директория теперь будет называться "docx"

Но чтобы переместить файлы, нам все еще нужно расширение .docx.

for fname in glob.glob(f'*.{type[1:]}')

Этим попросту отбираем все файлы, оканчивающиеся расширением .docx. Заметьте, что в f'*.{type[1:]}') нет пробелов.

Символ подстановки * обозначает, что подходит любое имя, если оно заканчивается на .docx. Поскольку мы уже включили точку в поиск, мы используем [1:], что значит «все после первого символа». В нашем примере это docx.

Что дальше? Перемещаем любые файлы с данным расширением в директорию с тем же названием.

shutil.move(fname, new_directory)

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

Способ 2

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

import os
import shutil
import glob

# перейти в папаку RandomFiles
os.chdir('./RandomFiles')
# добавить все файлы в данной папке в список
all_files = [x for x in os.listdir('.')]

# создать множество расширений имен файлов в этой папке
file_types = set((os.path.splitext(f)[1] for f in all_files))

for ftype in file_types:
    new_directory = ftype.replace(".", '')
    os.mkdir(new_directory)

    for fname in glob.glob(f'*.{ftype[1:]}'):
        shutil.move(fname, new_directory)

Оба варианта сработают, и все ваши файлы будут отсортированы по расширению.

ManageFiles/
 |
 |_create_random_files.py
 |_RandomFiles/
    |_doc
    |_docx
    |_html
    |_md
    |_odt
    |_ppt

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

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

Файлы

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

файловых методов Python

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

Метод Описание
close () Закрывает файл
detach () Возвращает разделенные необработанный поток из буфера
fileno () Возвращает число, которое представляет поток с точки зрения операционной системы
промывка () Промывает внутреннюю буфер
isatty () Возвращает, файловый поток интерактивный или нет
read () Возвращает содержимое файла
читаемый () Возвращает, файловый поток можно читать или нет
readline () Возвращает одну строку из файла
readlines () Возвращает список строк из файла
seek () Изменить позицию файла
seekable () Возвращает ли файл позволяет нам изменить положение файла
tell () Возвращает текущий файл позиция
truncate () Изменяет размер файла на указанный размер
с возможностью записи () Возвращает ли файл может быть записан или нет
write () Записывает указанный строка в файл
Writelines () Записывает список строк в файл

Узнайте больше об объекте файла в нашем руководстве по обработке файлов Python.


,

Python Файл открыт

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

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

demofile.txt

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

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

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

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

Пример

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

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

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

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

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

Пример

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

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

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

Строки чтения

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

Пример

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

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

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

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

Пример

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

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

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

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

Пример

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

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

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

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

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

Пример

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

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

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

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

,

7. Ввод и вывод — документация Python 3.8.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.пи: .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 () выглядит так:

,

No related posts.