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

Запись в файл Python. Перезапись файла Python

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

Создание файла, его открытие и закрытие

Работа с текстовым файлом в Python начинается с момента вызова функции open. Она принимает в качестве атрибутов путь к объекту на ПК и режим обработки. Вы можете указать абсолютный путь (это адрес размещения на жёстком диске) или относительный (речь идёт о координатах относительно папки проекта).

Что касается режима обработки файла, то при его выборе учитывайте его назначение («r» — для чтения, «w» — для записи). Таблица ниже позволит вам ознакомиться с режимами доступа к файлу в Python:

А вот пример простейшего взаимодействия с текстовым документом:

file = open("otus.txt", "w")
file.write("hello world")
file.close()
Здесь функция open принимает относительный путь, открывая его для записи. При этом, если в папке файл otus.txt будет отсутствовать, метод open создает его автоматически, после чего откроет для него нужный режим обработки.
Метод close закрывает файл, а это необходимо сделать, выполнив нужные вам действия с переменной file (иначе потеряете информацию). Впрочем, можно обойтись и без close, используя связку операторов with as (переменная, которая ссылается на файл, должна быть прописана после конструкции):
with open("otus.txt", "w") as file:
    file.write("hello world")
Метод write() для записи в файл в Python
В предыдущих примерах мы уже использовали метод write(). Он позволяет записывать любую строку в открытый файл. Помните, что строки в Python способны содержать не только текст, но и двоичные данные.
Запись в файл построчно выполняется посредством записи нужной вам строки с последующей записью \n— символа перевода строки.
Давайте ещё раз посмотрим на запись в файл с помощью метода write().
 Синтаксис:
Пример использования:
    my_file = open("otus.txt", "w")
my_file.write("Люблю Python!\nЭто крутой язык!")
my_file.close()
Код, представленный выше, создаст файл otus.txt , записав в него указанную строку.
Давайте теперь выполним запись списка поэлементно, где каждый элемент списка будет записан в новой строке:
lines = ["one", "two", "three"]
with open(r"C:\otus.txt", "w") as file:
    for  line in lines:
        file.write(line + '\n')
Этот код позволит создать небольшой массив lines, содержащий три строковых элемента: «one», «two» и «three». Благодаря функции open и связке операторов with as произойдёт открытие текстового файла otus.txt в корневом каталоге жёсткого диска C. Далее произойдёт запись всех элементов списка с помощью write. Символ \n обеспечит, чтобы каждая запись была выполнена с новой строки.
Работа с текстовыми файлами Python 3
Независимо от того, какое приложение вы используете, гарантировано, что в процессе его работы будет задействован ввод или вывод данных. В этом руководстве кратко описываются форматы, которые может обрабатывать Python. Затем мы рассмотрим, как открывать, считывать и записать текстовый файл в Python 3.
Для этого руководства нужно установить Python 3. Также на вашем компьютере должна быть установлена локальная среда программирования.
Python может с относительной легкостью обрабатывать различные форматы файлов:
Тип файла
Описание
Txt
Обычный текстовый файл хранит данные, которые представляют собой только символы (или строки) и не включает в себя структурированные метаданные.
CSV
Файл со значениями,для разделения которых используются запятые (или другие разделители). Что позволяет сохранять данные в формате таблицы.
HTML
HTML-файл хранит структурированные данные и используется большинством сайтов
JSON
JavaScript Object Notation — простой и эффективный формат, что делает его одним из часто используемых для хранения и передачи данных.
В этой статье основное внимание будет уделено формату txt.
Сначала нужно подготовить файл для работы. Для этого мы откроем любой текстовый редактор для python и создадим новый txt-файл, назовем его days.txt.
В этом файле необходимо ввести несколько строк. В приведенном ниже примере мы перечислим дни недели:
days.txt
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday
Затем сохраните файл. В нашем примере пользователь sammy сохранил файл здесь: /users/sammy/days.txt. Это будет важно на последующих этапах, когда откроем файл в Python.
Прежде чем написать программу, нужно создать файл для кода Python. С помощью текстового редактора создадим файл files.py. Чтобы упростить задачу, сохраните его в том же каталоге, что и файл days.txt:
/users/sammy/.
Чтобы открыть файл, сначала нужно каким-то образом связать его с переменной в Python. Этот процесс называется открытием файла. Сначала мы укажем Python, где находится файл.
Чтобы Python мог открыть файл, ему требуется путь к нему: days.txt -/users/sammy/days.txt. Затем создаем строковую переменную для хранения этой информации. В нашем скрипте files.py мы создадим переменную path и установим для нее значение days.txt.
files.py
path = '/users/sammy/days.txt'
Затем используем функцию Python open(), чтобы открыть файл days.txt. В качестве первого аргумента она принимает путь к файлу.
Эта функция также позволяет использовать многие другие параметры. Но наиболее важным является параметр, определяющий режим открытия файла. Он зависит от того, что вы хотите сделать с файлом.
Вот некоторые из существующих режимов:
‘r’: использовать для чтения;
‘w’: использовать для записи;
‘x’: использование для создания и записи в новый файл;
‘a’: использование для добавления к файлу;
‘r +’: использовать для чтения и записи в тот же файл.
В текущем примере нужно только считать данные из файла, поэтому будем использовать режим «r». Применим функцию open(), чтобы открыть файл days.txt и назначить его переменной days_file.
files.py
days_file = open(path,'r')
После открытия файла мы сможем прочитать его, что сделаем на следующем шаге.
Файл был открыт, и мы можем работать с ним через переменную, которую мы ему присвоили. Python предоставляет три связанные операции для чтения информации из файла. Покажем, как использовать каждую из них.
Первая операция <file>.read() возвращает все содержимое файла как одну строку.
days_file.read()
Вывод

'MondaynTuesdaynWednesdaynThursdaynFridaynSaturdaynSundayn'
Вторая операция <file>.readline() возвращает следующую строку файла (текст до следующего символа новой строки, включая сам символ). Проще говоря, эта операция считывает файл по частям.
days_file.readline()
Вывод
'Mondayn'
Поэтому, когда вы прочтете строку с помощью readline, она перейдет к следующей строке. Если вы снова вызовете эту операцию, она вернет следующую строку, прочитанную в файле.
days_file.readline()
Вывод
'Tuesdayn'
Последняя операция, <file>.readlines(), возвращает список строк в файле. При этом каждый элемент списка представляет собой одну строку.
days_file.readlines()
Вывод

['Mondayn', 'Tuesdayn', 'Wednesdayn', 'Thursdayn', 'Fridayn', 'Saturdayn', 'Sundayn']
Как только файл был прочитан с использованием одной из операций, его нельзя прочитать снова. Например, если вы запустите days_file.read(), за которой следует days_file.readlines(), вторая операция вернет пустую строку. Поэтому, когда вы захотите прочитать содержимое файла, вам нужно будет сначала открыть новую файловую переменную.
На этом этапе мы запишем новый файл, который включает в себя название «Days of the Week», и дни недели. Сначала создадим переменную title.
files.py
title = 'Days of the Weekn'
Также нужно сохранить дни недели в строковой переменной days. Открываем файл в режиме чтения, считываем файл и сохраняем вывод в новую переменную days.
files.py
path = '/users/sammy/days.txt'
days_file = open(path,'r')
days = days_file.read()
Теперь, когда у нас есть переменные для названия и дней недели, запишем их в новый файл. Сначала нужно указать расположение файла. Мы будем использовать каталог /users/sammy/. Также нужно указать новый файл, который мы хотим создать. Фактический путь будет /users/sammy/new_days.txt. Мы записываем его в переменную new_path. Затем открываем новый файл в режиме записи, используя функцию open() с режимом w.
files.py
new_path = '/users/sammy/new_days.txt'
new_days = open(new_path,'w')
Если файл new_days.txt уже существовал до открытия, его содержимое будет удалено, поэтому будьте осторожны при использовании режима «w».
Когда новый файл будет открыт, поместим в него данные, используя <file>.write(). Операция write принимает один параметр, который должен быть строкой, и записывает эту строку в файл.
Если хотите записать новую строку в файл, нужно указать символ новой строки. Мы записываем в файл заголовок, за которым следуют дни недели.
iles.py
new_days.write(title)
print(title)

new_days.write(days)
print(days)
Всякий раз, когда мы заканчиваем работу с файлом, нужно его закрыть. Мы покажем это в заключительном шаге.
Закрытие файла деактивирует соединение между файлом, сохраненным на жестком диске, и файловой переменной. Закрытие файлов также гарантирует, что другие программы смогут получить к ним доступ и безопасно сохранить данные. Закроем все наши файлы, используя функцию <file>.close().
files.py
days_file.close()
new_days.close()
Мы закончили обработку файлов в Python и можем перейти к просмотру кода.
Конечный результат должен выглядеть примерно так:
files.py
path = '/users/sammy/days.txt'
days_file = open(path,'r')
days = days_file.read()


new_path = '/users/sammy/new_days.txt'
new_days = open(new_path,'w')

title = 'Days of the Weekn'
new_days.write(title)
print(title)

new_days.write(days)
print(days)

days_file.close()
new_days.close()
После сохранения кода откройте терминал и запустите свой Python- скрипт, например:
python files.py
Результат должен выглядеть так:
Вывод
Days of the Week

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday
Теперь проверим код полностью, открыв файл new_days.txt. Если все пройдет хорошо, когда мы откроем этот файл, его содержимое должно выглядеть следующим образом:
new_days.txt
Days of the Week
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday
В этой статье мы рассказали, как работать с простыми текстовыми файлами в Python 3. Теперь вы сможете открывать, считывать, записывать и закрывать файлы в Python.
Дайте знать, что вы думаете по этой теме в комментариях. Мы крайне благодарны вам за ваши комментарии, лайки, отклики, подписки, дизлайки!
Вадим Дворниковавтор-переводчик статьи «How To Handle Plain Text Files in Python 3»
Python | Работа с файлами
Открытие и закрытие файлов
Последнее обновление: 29.04.2017
Python поддерживает множество различных типов файлов, но условно их можно разделить на два виде: текстовые и бинарные. Текстовые файлы  — это к примеру 

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

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

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

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

Открытие и закрытие файла
Чтобы начать работу с файлом, его надо открыть с помощью функции open(), которая имеет следующее формальное определение:
open(file, mode)
Первый параметр функции представляет путь к файлу. Путь файла может быть абсолютным, то есть начинаться с буквы диска, например, C://somedir/somefile.txt. 

 Либо можно быть относительным, например, somedir/somefile.txt — в этом случае поиск файла будет идти относительно 

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

 Существует 4 общих режима:
r (Read). Файл открывается для чтения. Если файл не найден, то генерируется исключение FileNotFoundError

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

 старые данные в нем стираются.

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

 то данные записываются в его конец.

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

После завершения работы с файлом его обязательно нужно закрыть методом close(). Данный метод освободит все связанные с файлом используемые ресурсы.
Например, откроем для записи текстовый файл «hello.txt»:
myfile = open("hello.txt", "w")

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

 В этом случае программа выпадет в ошибку, а ее выполнение не дойдет до вызова метода close, и соответственно файл не будет закрыт.
В этом случае мы можем обрабатывать исключения:
try:
    somefile = open("hello.txt", "w")
    try:
        somefile.write("hello world")
    except Exception as e:
        print(e)
    finally:
        somefile.close()
except Exception as ex:
    print(ex)
В данном случае вся работа с файлом идет во вложенном блоке try. И если вдруг возникнет какое-либо исключение, то в любом случае в блоке 

 finally файл будет закрыт.
Однако есть и более удобная конструкция — конструкция with:
with open(file, mode) as file_obj:
	инструкции
Эта конструкция определяет для открытого файла переменную file_obj и выполняет набор инструкций. После их выполнения файл автоматически закрывается. 

 Даже если при выполнении инструкций в блоке with возникнут какие-либо исключения, то файл все равно закрывается.
Так, перепишем предыдущий пример:
with open("hello.txt", "w") as somefile:
    somefile.write("hello world")
Python | Текстовые файлы
Текстовые файлы
Последнее обновление: 21.06.2017
Запись в текстовый файл
Чтобы открыть текстовый файл на запись, необходимо применить режим w (перезапись) или a (дозапись). Затем для записи применяется метод write(str), 

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

 предварительно нужно конвертировать в строку.
Запишем некоторую информацию в файл «hello.txt»:
with open("hello.txt", "w") as file:
    file.write("hello world")
Если мы откроем папку, в которой находится текущий скрипт Python, то увидем там файл hello.txt. Этот файл можно открыть в любом текстовом редакторе и при желании изменить.
Теперь дозапишем в этот файл еще одну строку:
with open("hello.txt", "a") as file:
    file.write("\ngood bye, world")
Дозапись выглядит как добавление строку к последнему символу в файле, поэтому, если необходимо сделать запись с новой строки, то можно использовать эскейп-последовательность «\n». 

 В итоге файл hello.txt будет иметь следующее содержимое:
hello world
good bye, world
Еще один способ записи в файл представляет стандартный метод print(), который применяется для вывода данных на консоль:
with open("hello.txt", "a") as hello_file:
    print("Hello, world", file=hello_file)
Для вывода данных в файл в метод print в качестве второго параметра передается название файла через параметр file. А первый параметр представляет записываемую 

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

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

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

Например, считаем выше записанный файл построчно:
with open("hello.txt", "r") as file:
    for line in file:
        print(line, end="")
Несмотря на то, что мы явно не применяем метод readline() для чтения каждой строки, но в при переборе файла этот метод автоматически вызывается 

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

 print передается значение end="".
Теперь явным образом вызовем метод readline() для чтения отдельных строк:
with open("hello.txt", "r") as file:
    str1 = file.readline()
    print(str1, end="")
    str2 = file.readline()
    print(str2)
Консольный вывод:
hello world
good bye, world
Метод readline можно использовать для построчного считывания файла в цикле while:
with open("hello.txt", "r") as file:
    line = file.readline()
    while line:
        print(line, end="")
        line = file.readline()
Если файл небольшой, то его можно разом считать с помощью метода read():
with open("hello.txt", "r") as file:
    content = file.read()
    print(content)
И также применим метод readlines() для считывания всего файла в список строк:
with open("hello.txt", "r") as file:
    contents = file.readlines()
    str1 = contents[0]
    str2 = contents[1]
    print(str1, end="")
    print(str2)
При чтении файла мы можем столкнуться с тем, что его кодировка не совпадает с ASCII. В этом случае мы явным образом можем указать кодировку с помощью 

 параметра encoding:
filename = "hello.txt"
with open(filename, encoding="utf8") as file:
    text = file.read()
Теперь напишем небольшой скрипт, в котором будет записывать введенный пользователем массив строк и считывать его обратно из файла на консоль:
# имя файла
FILENAME = "messages.txt"
# определяем пустой список
messages = list()

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

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

# считываем сообщения из файла
print("Считанные сообщения")
with open(FILENAME, "r") as file:
    for message in file:
        print(message, end="")
Пример работы программы:
Введите строку 1: hello
Введите строку 2: world peace
Введите строку 3: great job
Введите строку 4: Python
Считанные сообщения
hello
world peace
great job
Python
Чтение файлов — Документация Python для сетевых инженеров 3.0
В Python есть несколько методов чтения файла:
read — считывает содержимое файла в строку
readline — считывает файл построчно
readlines — считывает строки файла и создает список из строк
Посмотрим как считывать содержимое файлов, на примере файла r1.txt:
!
service timestamps debug datetime msec localtime show-timezone year
service timestamps log datetime msec localtime show-timezone year
service password-encryption
service sequence-numbers
!
no ip domain lookup
!
ip ssh version 2
!
read
Метод read — считывает весь файл в одну строку.
Пример использования метода read:
In [1]: f = open('r1.txt')

In [2]: f.read()
Out[2]: '!\nservice timestamps debug datetime msec localtime show-timezone year\nservice timestamps log datetime msec localtime show-timezone year\nservice password-encryption\nservice sequence-numbers\n!\nno ip domain lookup\n!\nip ssh version 2\n!\n'

In [3]: f.read()
Out[3]: ''
При повторном чтении файла в 3 строке, отображается пустая строка. Так
 происходит из-за того, что при вызове метода read, считывается
 весь файл. И после того, как файл был считан, курсор остается в конце
 файла. Управлять положением курсора можно с помощью метода seek.
readline
Построчно файл можно считать с помощью метода readline:
In [4]: f = open('r1.txt')

In [5]: f.readline()
Out[5]: '!\n'

In [6]: f.readline()
Out[6]: 'service timestamps debug datetime msec localtime show-timezone year\n'
Но чаще всего проще пройтись по объекту file в цикле, не используя
 методы read...:
In [7]: f = open('r1.txt')

In [8]: for line in f:
   ...:     print(line)
   ...:
!

service timestamps debug datetime msec localtime show-timezone year

service timestamps log datetime msec localtime show-timezone year

service password-encryption

service sequence-numbers

!

no ip domain lookup

!

ip ssh version 2

!
readlines
Еще один полезный метод — readlines. Он считывает строки файла в
 список:
In [9]: f = open('r1.txt')

In [10]: f.readlines()
Out[10]:
['!\n',
 'service timestamps debug datetime msec localtime show-timezone year\n',
 'service timestamps log datetime msec localtime show-timezone year\n',
 'service password-encryption\n',
 'service sequence-numbers\n',
 '!\n',
 'no ip domain lookup\n',
 '!\n',
 'ip ssh version 2\n',
 '!\n']
Если нужно получить строки файла, но без перевода строки в конце, можно
 воспользоваться методом split и как разделитель, указать символ
 \n:
In [11]: f = open('r1.txt')

In [12]: f.read().split('\n')
Out[12]:
['!',
 'service timestamps debug datetime msec localtime show-timezone year',
 'service timestamps log datetime msec localtime show-timezone year',
 'service password-encryption',
 'service sequence-numbers',
 '!',
 'no ip domain lookup',
 '!',
 'ip ssh version 2',
 '!',
 '']
Обратите внимание, что последний элемент списка — пустая строка.
Если перед выполнением split, воспользоваться методом
 rstrip, список будет без пустой строки в конце:
In [13]: f = open('r1.txt')

In [14]: f.read().rstrip().split('\n')
Out[14]:
['!',
 'service timestamps debug datetime msec localtime show-timezone year',
 'service timestamps log datetime msec localtime show-timezone year',
 'service password-encryption',
 'service sequence-numbers',
 '!',
 'no ip domain lookup',
 '!',
 'ip ssh version 2',
 '!']
seek
До сих пор, файл каждый раз приходилось открывать заново, чтобы снова
 его считать. Так происходит из-за того, что после методов чтения, курсор
 находится в конце файла. И повторное чтение возвращает пустую строку.
Чтобы ещё раз считать информацию из файла, нужно воспользоваться методом
 seek, который перемещает курсор в необходимое положение.
Пример открытия файла и считывания содержимого:
In [15]: f = open('r1.txt')

In [16]: print(f.read())
!
service timestamps debug datetime msec localtime show-timezone year
service timestamps log datetime msec localtime show-timezone year
service password-encryption
service sequence-numbers
!
no ip domain lookup
!
ip ssh version 2
!
Если вызывать ещё раз метод read, возвращается пустая строка:
Но с помощью метода seek можно перейти в начало файла (0 означает
 начало файла):
После того как с помощью seek курсор был переведен в начало
 файла, можно опять считывать содержимое:
In [19]: print(f.read())
!
service timestamps debug datetime msec localtime show-timezone year
service timestamps log datetime msec localtime show-timezone year
service password-encryption
service sequence-numbers
!
no ip domain lookup
!
ip ssh version 2
!
Работа с файлами в Python: основы
Python — это высокоуровневый язык программирования, который способен решать множество повседневных задач, начиная от резервного копирования и чтения e-mail, заканчивая созданием небольшой игры. В этой статье мы разберем, как работать с файлами в Python.
Типы файлов
Особые комбинации данных, записанные в последовательностях битов, называются файлами. Информация в них оформлена, структурирована и обладает собственным именем.
В Python выделяют два типа файлов:
Текстовые включают в себя то, что может прочесть человек. Открыть их можно, запустив блокнот или другие классические редакторы. Обычно такие файлы имеют расширение .txt или .rtf.
Бинарные типы выводятся в закодированном формате, то есть с использованием «0» и «1». Они представляют собой комбинации битов и хранятся в расширении .bin.
Операции с файлами
Существует несколько вариантов действий с файлами. Рассмотрим основные операции:
открытие;
чтение или запись;
переименование;
закрытие.
Давайте разберем каждую из них.
Открытие
Для запуска файлов предусмотрена встроенная функция под названием open(). С ее помощью можно открыть любой документ. Python же будет формировать внутри себя на его основе объект. Функция принимает два следующих аргумента:
file — название файла, где также прописывается к нему путь ;
mode — запуск, при котором по умолчанию установлен режим «только для чтения».
В системе предусмотрен ряд режимов для открытия, среди которых:
для чтения или записи;
для чтения и записи;
запуск для присоединения новой информации.
Каждый из этих режимов может обладать текстовым и бинарным вариантами. Во втором случае к буквенному указателю добавляется буква «b». Эти режимы могут комбинироваться.
Режим
Возможности
r
Только чтение
w
Запись. Если не найден, то создается новый
x
Запись. Если не найден, вызывается исключение
a
Запись. Не стирает данные, а добавляет в конец
t
Открытие в формате текстового файла
b
Открытие в виде бинарного файла
+
Работа в варианте и записи, и чтения
После открытия файла сгенерируется особый файловый объект и вы сможете получить о нем сведения. Для этого существуют специальные атрибуты:
.name – содержит в себе имя;
.closed – показывает, закрыт ли документ;
.mode – отображает вариант доступа;
.softspace – определяет необходимость добавления пробела.
Синтаксис метода выглядит следующим образом:
f = open(file_name, access_mode)
или
f = open('exmp.txt','r')
Чтение
Python позволяет читать файлы или записывать в них информацию. Важно, чтобы открытие было произведено в том формате, который позволяет выполнять эти действия.
Метод read() предназначен для чтения файла, запущенного в варианте «только для чтения». Он принимает в качестве аргумента число символов, которые требуется прочесть. То есть, если вы передадите цифру 10, то будут отображены только первые 10 знаков.
Например:
f = open('exmp.txt','r')

f.read(10)
Следующей функцией будет readline(). Она получает содержимое документа по строкам и подходит для больших объемов. Здесь также существует удобный способ, позволяющий не считывать весь файл полностью, а обращаться только к нужным строкам. Это возможно благодаря объекту io.TextIOWrapper.
Запись
Для записи в файлы Python использует метод write(). При этом важно, чтобы открытие осуществлялось в режиме записи. Если файла не существовало, он будет сгенерирован. Еще одним аспектом при использовании метода является то, что в него могут передаваться исключительно строки. Если вы планируете передавать другой тип данных, то лучше заранее форматировать его в строковый тип.
Метод write() может записывать и большие объемы информации. Для этого нужно представить их в виде списка строк. Аналогично функции считывания, для записи существует построчный вариант writelines(). Python самостоятельно не расставляет переносы, поэтому продумать этот момент лучше заранее.
Пример синтаксиса:
f = open('exmp.txt','w') 

f.write('Привет Мир')

f.close()
Менее популярным, но при этом одним из наиболее удобных способов записи можно назвать метод print(). Он выводит информацию в консоль, но если передавать в необязательный аргумент тип объекта file, то поток будет перенаправляться из консоли напрямую в файл. Главным достоинством такого подхода можно считать то, что метод print() принимает не только строковые данные. Это значит, что при необходимости он самостоятельно конвертирует информацию.
Python позволяет указывать позицию нахождения в файле. После первичного обращения вы можете получить пустую строку. Это случается из-за того, что указатель перемещен в конец. Для точного определения его позиции предусмотрен метод tell(), который говорит, в каком количестве байт от начала он расположен в данный момент. Затем можно воспользоваться методом seek(), который переведет нас на требуемую позицию. В нем также следует указывать количество байт, при этом 0 определяет начало файла, 1 – текущую позицию, 2 – конец.
Изменение названия
Еще одной возможностью при работе с файлами будет изменение их названия. Для этого используется rename(), но предварительно необходимо импортировать специальный модуль os.
Например:
import os

os.rename(exmp,file) # где exmp – изначальное имя файла, а file – новое
Закрытие
Открыв файл и закончив все манипуляции с ним, необходимо будет его закрыть, тем самым освободив ресурсы и удалив лишние данные. Python способен самостоятельно закрыть файл, когда объект передается другому документу. Но давайте рассмотрим, какие существуют варианты корректного закрытия:
метод close(), прописанный после всех необходимых действий;
метод try/finally — при появлении операций с исключениями файл будет автоматически закрыт;
инструкция with/as, упрощающая обработку исключений, поэтому метод close() в этом случае будет не нужен.
Последний способ считается наиболее предпочтительным, так как в нем Python самостоятельно закрывает файл. Это значит, что вам не нужно дополнительно напоминать об этом в коде. Также в этом случае не будут генерироваться исключения, например, если файл не обнаружен.
Синтаксисы вариантов закрытия оформляются в следующем виде:
 для метода close():
f = open('exmp.txt','r')

f.close()
 для комбинации try/finally:
f = open('exmp.txt','r')

try:

#код

finally:

f.close()
для инструкции with/as:
with open('exmp.txt') as f:

    #код
Ошибки
В ряде случаев при работе с файлами могут происходить ошибки. Файл может закрыться, если к нему будут обращаться несколько программ одновременно, или произойдет ошибка разрешения, из-за которой возникнет сбой в работе. В таких случаях будет появляться IOError.
Выявить ошибки и решить их можно с помощью оператора with или конструкции кода try/except, которые применялись для корректного закрытия файлов. Они сразу предусматривают исключения, что значительно упрощает процесс работы кода.
Файлы. Работа с файлами. — Питошка
В данной статье мы рассмотрим встроенные средства 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 имеет несколько встроенных модулей и функций для работы с файлами. Эти функции распределены по нескольким модулям, таким как  os ,  os.path ,  shutil  и  pathlib , и это лишь некоторые из них. В этой статье собраны в одном месте многие функции, которые вам необходимо знать для выполнения наиболее распространенных операций с файлами в Python.
  Из этого руководства вы узнаете, как: 
 Получить свойства файла
 Создать каталог
 Шаблоны соответствия в именах файлов
 Переход по деревьям каталогов
 Создавать временные файлы и каталоги
 Удалить файлы и каталоги
 Копирование, перемещение или переименование файлов и каталогов
 Создание и распаковка архивов ZIP и TAR
 Открытие нескольких файлов с помощью модуля  fileinput 
  Бесплатный бонус:  5 мыслей о Python Mastery, бесплатный курс для разработчиков Python, который показывает вам план развития и образ мышления, который вам понадобится, чтобы вывести свои навыки Python на новый уровень.
 Шаблон Python «с открытым (…) как…» 
 Чтение и запись данных в файлы с помощью Python довольно просты. Для этого необходимо сначала открыть файлы в соответствующем режиме. Вот пример того, как использовать шаблон Python «with open (…) as…» для открытия текстового файла и чтения его содержимого:
  с open ('data.txt', 'r') как f:
    data = f.read ()
  
  open ()  принимает в качестве аргументов имя файла и режим.  r  открывает файл в режиме только для чтения.Чтобы записать данные в файл, передайте вместо этого  w  в качестве аргумента:
  с open ('data.txt', 'w') как f:
    data = 'некоторые данные для записи в файл'
    f.write (данные)
  
 В приведенных выше примерах  open ()  открывает файлы для чтения или записи и возвращает дескриптор файла (в данном случае  f ), который предоставляет методы, которые можно использовать для чтения или записи данных в файл. Ознакомьтесь с разделами «Чтение и запись файлов в Python» и «Работа с файловым вводом-выводом в Python» для получения дополнительной информации о том, как читать и записывать файлы.
 Получение листинга каталога 
 Предположим, в вашем текущем рабочем каталоге есть подкаталог с именем  my_directory , содержащий следующее содержимое:
  my_directory /
|
├── sub_dir /
| ├── bar.py
| └── foo.py
|
├── sub_dir_b /
| └── file4.txt
|
├── sub_dir_c /
| ├── config.py
| └── file5.txt
|
├── file1.py
├── file2.csv
└── file3.txt
  
 Встроенный модуль  os  имеет ряд полезных функций, которые можно использовать для составления списка содержимого каталогов и фильтрации результатов.Чтобы получить список всех файлов и папок в определенном каталоге файловой системы, используйте  os.listdir ()  в устаревших версиях Python или  os.scandir ()  в Python 3.x.  os.scandir ()  — предпочтительный метод для использования, если вы также хотите получить свойства файла и каталога, такие как размер файла и дата модификации.
 Список каталогов
 в устаревших версиях Python 
 В версиях Python до Python 3  os.listdir ()  — это метод, используемый для получения списка каталогов:
>>>
  >>> импорт ОС
>>> entry = os.listdir ('мой_директория /')
  
  os.listdir ()  возвращает список Python, содержащий имена файлов и подкаталогов в каталоге, заданном аргументом пути:
>>>
  >>> os.listdir ('my_directory /')
['sub_dir_c', 'file1.py', 'sub_dir_b', 'file3.txt', 'file2.csv', 'sub_dir']
  
 Такой список каталогов нелегко прочитать. Распечатка вывода вызова на  os.listdir ()  с использованием цикла помогает навести порядок:
>>>
  >>> entry = os.listdir ('мой_директория /')
>>> для записи в записи:
... печать (запись)
...
...
sub_dir_c
file1.py
sub_dir_b
file3.txt
file2.csv
sub_dir
  
 Список каталогов
 в современных версиях Python 
 В современных версиях Python альтернативой  os.listdir ()  является использование  os.scandir ()  и  pathlib.Path () .
  os.scandir ()  был представлен в Python 3.5 и задокументирован в PEP 471.  os.scandir ()  при вызове возвращает итератор, а не список:
>>>
  >>> импорт ОС
>>> entry = os.scandir ('мой_каталог /')
>>> записи
<объект posix.ScandirIterator по адресу 0x7f5b047f3690>
  
  ScandirIterator  указывает на все записи в текущем каталоге. Вы можете перебрать содержимое итератора и распечатать имена файлов:
  импорт ОС

с os.scandir ('my_directory /') в качестве записей:
    для записи в записи:
        печать (entry.name)
  
 Здесь  os.scandir ()  используется вместе с оператором  с , поскольку он поддерживает протокол диспетчера контекста.Использование диспетчера контекста закрывает итератор и автоматически освобождает полученные ресурсы после того, как итератор исчерпан. Результатом является распечатка имен файлов в  my_directory / , как вы видели в примере  os.listdir () :
  sub_dir_c
file1.py
sub_dir_b
file3.txt
file2.csv
sub_dir
  
 Другой способ получить список каталогов — использовать модуль  pathlib :
  из пути импорта pathlib

записи = Путь ('my_directory /')
для записи в записи.iterdir ():
    печать (entry.name)
  
 Объекты, возвращаемые  Path , являются объектами  PosixPath  или  WindowsPath  в зависимости от ОС.
  pathlib.Path () Объекты  имеют метод  .iterdir ()  для создания итератора всех файлов и папок в каталоге. Каждая запись, выданная  .iterdir () , содержит информацию о файле или каталоге, такую ​​как его имя и атрибуты файла.  pathlib  впервые был представлен в Python 3.4 и является отличным дополнением к Python, предоставляющим объектно-ориентированный интерфейс для файловой системы.
 В приведенном выше примере вы вызываете  pathlib.Path ()  и передаете ему аргумент пути. Далее следует вызов  .iterdir () , чтобы получить список всех файлов и каталогов в  my_directory .
  pathlib  предлагает набор классов, содержащих большинство общих операций над путями простым и объектно-ориентированным способом. Использование  pathlib  более, если не столь же эффективно, как использование функций в  os .Еще одно преимущество использования  pathlib  по сравнению с  os  состоит в том, что это уменьшает количество операций импорта, которые необходимо выполнить для управления путями файловой системы. Для получения дополнительной информации прочтите модуль pathlib Python 3: Укрощение файловой системы.
 Выполнение приведенного выше кода дает следующее:
  sub_dir_c
file1.py
sub_dir_b
file3.txt
file2.csv
sub_dir
  
 Использование  pathlib.Path ()  или  os.scandir ()  вместо  os.listdir ()  является предпочтительным способом получения списка каталогов, особенно когда вы работаете с кодом, которому требуется тип файла и информация об атрибутах файла. pathlib.Path ()  предлагает большую часть функций обработки файлов и путей, которые есть в  os  и  shutil , и его методы более эффективны, чем некоторые из этих модулей. Вскоре мы обсудим, как получить свойства файла.
 Вот еще раз функции листинга каталогов:
 Функция
 Описание
  os.listdir () 
 Возвращает список всех файлов и папок в каталоге
  ос.скандир () 
 Возвращает итератор всех объектов в каталоге, включая информацию об атрибутах файла.
  pathlib.Path.iterdir () 
 Возвращает итератор всех объектов в каталоге, включая информацию об атрибутах файла.
 Эти функции возвращают список из  всего  в каталоге, включая подкаталоги. Это не всегда может быть тем поведением, которое вам нужно. В следующем разделе будет показано, как отфильтровать результаты из списка каталогов.
 Список всех файлов в каталоге 
 В этом разделе показано, как распечатать имена файлов в каталоге с помощью  os.listdir () ,  os.scandir ()  и  pathlib.Path () . Чтобы отфильтровать каталоги и перечислить только файлы из списка каталогов, созданного  os.listdir () , используйте  os.path :
  импорт ОС

# Список всех файлов в каталоге с помощью os.listdir
basepath = 'my_directory /'
для записи в os.listdir (базовый путь):
    если os.path.isfile (os.path.join (базовый путь, запись)):
        печать (запись)
  
 Здесь вызов  os.listdir ()  возвращает список всего по указанному пути, а затем этот список фильтруется с помощью  os.path.isfile () , чтобы распечатать только файлы, а не каталоги. Это дает следующий результат:
  file1.py
file3.txt
file2.csv
  
 Более простой способ перечислить файлы в каталоге — использовать  os.scandir ()  или  pathlib.Path () :
  импорт ОС

# Вывести список всех файлов в каталоге с помощью scandir ()
basepath = 'my_directory /'
с os.scandir (basepath) как записи:
    для записи в записи:
        если entry.is_file ():
            печать (entry.name)
  
 Использование  os.scandir ()  имеет то преимущество, что выглядит чище и легче для понимания, чем использование  os.listdir () , хотя это на одну строку кода длиннее. Вызов  entry.is_file ()  для каждого элемента в  ScandirIterator  возвращает  True , если объект является файлом. Распечатав имена всех файлов в каталоге, вы получите следующий результат:
  файл1.ру
file3.txt
file2.csv
  
 Вот как вывести список файлов в каталоге с помощью  pathlib.Path () :
  из пути импорта pathlib

basepath = Путь ('my_directory /')
files_in_basepath = basepath.iterdir ()
для элемента в files_in_basepath:
    если item.is_file ():
        печать (название предмета)
  
 Здесь вы вызываете  .is_file ()  для каждой записи, полученной с помощью  .iterdir () . На выходе такая же:
  file1.py
файл3.текст
file2.csv
  
 Приведенный выше код можно сделать более кратким, если объединить цикл  for  и оператор  if  в одно выражение генератора. У Дэна Бадера есть отличная статья о выражениях-генераторах и понимании списков.
 Модифицированная версия выглядит так:
  из пути импорта pathlib

# Вывести список всех файлов в каталоге, используя pathlib
basepath = Путь ('my_directory /')
files_in_basepath = (запись для входа в basepath.iterdir (), если запись.is_file ())
для элемента в files_in_basepath:
    печать (название предмета)
  
 Результат точно такой же, как в предыдущем примере. В этом разделе показано, что фильтрация файлов или каталогов с использованием  os.scandir ()  и  pathlib.Path ()  более интуитивно понятна и выглядит чище, чем использование  os.listdir ()  в сочетании с  os.path .
 Список подкаталогов 
 Чтобы вывести список подкаталогов вместо файлов, используйте один из следующих способов.Вот как использовать  os.listdir ()  и  os.path () :
  импорт ОС

# Список всех подкаталогов с помощью os.listdir
basepath = 'my_directory /'
для записи в os.listdir (базовый путь):
    если os.path.isdir (os.path.join (basepath, entry)):
        печать (запись)
  
 Управление путями файловой системы таким способом может быстро стать обременительным, если у вас есть несколько вызовов  os.path.join () . Запуск этого на моем компьютере дает следующий результат:
  sub_dir_c
sub_dir_b
sub_dir
  
 Вот как использовать  os.scandir () :
  импорт ОС

# Вывести список всех подкаталогов с помощью scandir ()
basepath = 'my_directory /'
с os.scandir (basepath) в качестве записей:
    для записи в записи:
        если entry.is_dir ():
            печать (entry.name)
  
 Как и в примере со списком файлов, здесь вы вызываете  .is_dir ()  для каждой записи, возвращаемой  os.scandir () . Если запись является каталогом,  .is_dir ()  возвращает  True , и имя каталога распечатывается.Вывод такой же, как и выше:
  sub_dir_c
sub_dir_b
sub_dir
  
 Вот как использовать  pathlib.Path () :
  из пути импорта pathlib

# Список всех подкаталогов с помощью pathlib
basepath = Путь ('my_directory /')
для входа в basepath.iterdir ():
    если entry.is_dir ():
        печать (entry.name)
  
 Вызов  .is_dir ()  для каждой записи базового пути  Итератор  проверяет, является ли запись файлом или каталогом.Если запись является каталогом, ее имя выводится на экран, а результат такой же, как и в предыдущем примере:
  sub_dir_c
sub_dir_b
sub_dir
  
 Получение атрибутов файла 
 Python упрощает получение атрибутов файла, таких как размер файла и время изменения. Это делается через  os.stat () ,  os.scandir ()  или  pathlib.Path () .
  os.scandir ()  и  pathlib.Path ()  получить список каталогов с объединенными атрибутами файлов. Это может быть потенциально более эффективным, чем использование  os.listdir ()  для вывода списка файлов и последующего получения информации об атрибутах для каждого файла.
 Примеры ниже показывают, как получить время последнего изменения файлов в  my_directory / . Вывод в секундах:
>>>
  >>> импорт ОС
>>> с os.scandir ('my_directory /') как dir_contents:
... для записи в dir_contents:
... info = entry.stat ()
... печать (info.st_mtime)
...
153
99,0052035
15369,6324475
1538998552.2402923
1540233322.4009316
15371
.0497339
1540266380.3434134
  
  os.scandir ()  возвращает объект  ScandirIterator . Каждая запись в объекте  ScandirIterator  имеет метод  .stat () , который извлекает информацию о файле или каталоге, на который он указывает.  .stat ()  предоставляет такую ​​информацию, как размер файла и время последней модификации.В приведенном выше примере код распечатывает атрибут  st_mtime , который указывает время последнего изменения содержимого файла.
 Модуль  pathlib  имеет соответствующие методы для получения информации о файлах, которые дают те же результаты:
>>>
  >>> from pathlib import Path
>>> current_dir = Путь ('my_directory')
>>> для пути в current_dir.iterdir ():
... информация = путь.stat ()
... печать (info.st_mtime)
...153
99,0052035
15369,6324475
1538998552.2402923
1540233322.4009316
15371
.0497339
1540266380.3434134
  
 В приведенном выше примере код проходит через объект, возвращаемый функцией  .iterdir () , и извлекает атрибуты файла с помощью вызова  .stat ()  для каждого файла в списке каталогов. Атрибут  st_mtime  возвращает значение с плавающей запятой, которое представляет секунды с начала эпохи. Чтобы преобразовать значения, возвращаемые  st_mtime  для отображения, вы можете написать вспомогательную функцию для преобразования секунд в объект  datetime :
  из datetime import datetime
из os import scandir

def convert_date (отметка времени):
    d = дата и время.utcfromtimestamp (отметка времени)
    formated_date = d.strftime ('% d% b% Y')
    вернуть formated_date

def get_files ():
    dir_entries = scandir ('мой_каталог /')
    для записи в dir_entries:
        если entry.is_file ():
            info = entry.stat ()
            print (f '{entry.name} \ t Последнее изменение: {convert_date (info.st_mtime)}')
  
 Это сначала получит список файлов в  my_directory  и их атрибуты, а затем вызовет  convert_date ()  для преобразования времени последнего изменения каждого файла в удобочитаемую форму. convert_date ()  использует  .strftime ()  для преобразования времени в секундах в строку.
 В  .strftime ()  передаются следующие аргументы:
  % d :  день месяца
  % b :  в месяц, сокращенно
  % Y :  год
 Вместе эти директивы производят вывод, который выглядит следующим образом:
>>>
  >>> get_files ()
файл1.py Последнее изменение: 4 октября 2018 г.
file3.txt Последнее изменение: 17 сен 2018
file2.txt Последнее изменение: 17 сен 2018
  
 Синтаксис преобразования даты и времени в строки может сбивать с толку. Чтобы узнать больше об этом, ознакомьтесь с официальной документацией по нему. Еще одна удобная ссылка, которую легко запомнить, — это http://strftime.org/.
 Создание каталогов 
 Рано или поздно программы, которые вы пишете, должны будут создавать каталоги, чтобы хранить в них данные. os  и  pathlib  включают функции для создания каталогов. Мы рассмотрим это:
 Функция
 Описание
  os.mkdir () 
 Создает единственный подкаталог
  pathlib.Path.mkdir () 
 Создает один или несколько каталогов
  os.makedirs () 
 Создает несколько каталогов, включая промежуточные каталоги
 Создание единого каталога 
 Чтобы создать отдельный каталог, передайте путь к каталогу в качестве параметра  os.mkdir () :
  импорт ОС

os.mkdir ('каталог_пример /')
  
 Если каталог уже существует,  os.mkdir ()  вызывает  FileExistsError . В качестве альтернативы вы можете создать каталог, используя  pathlib :
  из пути импорта pathlib

p = Путь ('example_directory /')
p.mkdir ()
  
 Если путь уже существует,  mkdir ()  вызывает  FileExistsError :
>>>
  >>> п.mkdir ()
Отслеживание (последний вызов последний):
  Файл '', строка 1, в 
  Файл '/usr/lib/python3.5/pathlib.py', строка 1214, в mkdir
    self._accessor.mkdir (сам, режим)
  Файл '/usr/lib/python3.5/pathlib.py', строка 371, в оболочке
    вернуть strfunc (str (pathobj), * args)
FileExistsError: [Errno 17] Файл существует: '.'
[Errno 17] Файл существует: '.'
  
 Чтобы избежать подобных ошибок, перехватите ошибку, когда она возникает, и сообщите своему пользователю:
  из пути импорта pathlib

p = Путь ('example_directory')
пытаться:
    п.mkdir ()
кроме FileExistsError как exc:
    печать (искл)
  
 В качестве альтернативы вы можете игнорировать  FileExistsError , передав аргумент  exist_ok = True  в  .mkdir () :
  из пути импорта pathlib

p = Путь ('example_directory')
p.mkdir (exist_ok = True)
  
 Это не вызовет ошибки, если каталог уже существует.
 Создание нескольких каталогов 
  os.makedirs ()  похож на  os.mkdir () . Разница между ними в том, что  os.makedirs ()  может не только создавать отдельные каталоги, но и использовать их для создания деревьев каталогов. Другими словами, он может создавать любые необходимые промежуточные папки, чтобы гарантировать существование полного пути.
  os.makedirs ()  аналогичен запуску  mkdir -p  в Bash. Например, чтобы создать группу каталогов типа  2018/10/05 , все, что вам нужно сделать, это следующее:
  импорт ОС


Операционные системы.makedirs ('2018/10/05')
  
 Будет создана вложенная структура каталогов, содержащая папки 2018, 10 и 05:
 .
|
└── 2018 /
    └── 10 /
        └── 05 /
  
  .makedirs ()  создает каталоги с разрешениями по умолчанию. Если вам нужно создать каталоги с разными разрешениями, вызовите  .makedirs ()  и перейдите в режим, в котором вы хотите, чтобы каталоги создавались в:
  импорт ОС

os.makedirs ('2018/10/05', mode = 0o770)
  
 Это создает структуру каталогов  2018/10/05  и дает владельцу и группе пользователей права на чтение, запись и выполнение.Режим по умолчанию —  0o777 , и биты прав доступа к файлам существующих родительских каталогов не изменяются. Дополнительные сведения о правах доступа к файлам и о том, как применяется режим, см. В документации.
 Запустите дерево  , чтобы убедиться, что были применены правильные разрешения:
  $ дерево -p -i.
.
[drwxrwx ---] 2018 г.
[drwxrwx ---] 10
[drwxrwx ---] 05
  
 Распечатывает дерево каталогов текущего каталога.  дерево  обычно используется для отображения содержимого каталогов в древовидном формате.Передав ему аргументы  -p  и  -i , вы распечатаете имена каталогов и информацию о правах доступа к файлам в вертикальном списке.  -p  распечатывает права доступа к файлу, а  -i  заставляет  tree  создавать вертикальный список без строк отступов.
 Как видите, все каталоги имеют  770  разрешений. Альтернативный способ создания каталогов — использовать  .mkdir ()  из  pathlib.Path :
  импорт pathlib

p = pathlib.Путь ('2018/10/05')
p.mkdir (родители = Истина)
  
 Передача  parent = True  в  Path.mkdir ()  заставляет его создать каталог  05  и все родительские каталоги, необходимые для того, чтобы путь был действительным.
 По умолчанию  os.makedirs ()  и  Path.mkdir ()  вызывают  OSError , если целевой каталог уже существует. Это поведение можно переопределить (начиная с Python 3.2), передав  exist_ok = True  в качестве аргумента ключевого слова при вызове каждой функции.
 Выполнение приведенного выше кода создает структуру каталогов, подобную приведенной ниже, за один раз:
 .
|
└── 2018 /
    └── 10 /
        └── 05 /
  
 Я предпочитаю использовать  pathlib  при создании каталогов, потому что я могу использовать ту же функцию для создания одиночных или вложенных каталогов.
 Сопоставление с шаблоном имени файла 
 Получив список файлов в каталоге одним из описанных выше методов, вы, скорее всего, захотите найти файлы, соответствующие определенному шаблону.
 Вам доступны следующие методы и функции:
  заканчивается с ()  и  начинается с ()  строковых методов
  fnmatch.fnmatch () 
  glob.glob () 
  pathlib.Path.glob () 
 Каждый из них обсуждается ниже. Примеры в этом разделе будут выполняться в каталоге с именем  some_directory , который имеет следующую структуру:
 .|
├── sub_dir /
| ├── file1.py
| └── file2.py
|
├── admin.py
├── data_01_backup.txt
├── data_01.txt
├── data_02_backup.txt
├── data_02.txt
├── data_03_backup.txt
├── data_03.txt
└── tests.py
  
 Если вы используете оболочку Bash, вы можете создать указанную выше структуру каталогов с помощью следующих команд:
  $ mkdir some_directory
$ cd some_directory /
$ mkdir sub_dir
$ touch sub_dir / file1.py sub_dir / file2.py
$ touch data_ {01..03} .txt data_ {01..03} _backup.txt admin.py tests.py
  
 Это создаст каталог  some_directory / , перейдет в него, а затем создаст  sub_dir . Следующая строка создает  file1.py  и  file2.py  в  sub_dir , а последняя строка создает все остальные файлы с использованием расширения. Чтобы узнать больше о расширении оболочки, посетите этот сайт.
 Использование строковых методов 
 Python имеет несколько встроенных методов для изменения и управления строками. Два из этих методов, .Startwith ()  и  .endswith ()  полезны при поиске шаблонов в именах файлов. Для этого сначала получите список каталогов, а затем переберите его:
>>>
  >>> импорт ОС

>>> # Получить файлы .txt
>>> для f_name в os.listdir ('some_directory'):
... если f_name.endswith ('. txt'):
... печать (f_name)
  
 Приведенный выше код находит все файлы в  some_directory / , перебирает их и использует .endwith () , чтобы распечатать имена файлов с расширением  .txt . Запуск этого на моем компьютере дает следующий результат:
  data_01.txt
data_03.txt
data_03_backup.txt
data_02_backup.txt
data_02.txt
data_01_backup.txt
  
 Сопоставление простого имени файла с шаблоном с использованием 
 fnmatch 
 Строковые методы ограничены в возможностях сопоставления.  fnmatch  имеет более продвинутые функции и методы для сопоставления с образцом.Мы рассмотрим  fnmatch.fnmatch () , функцию, которая поддерживает использование подстановочных знаков, таких как  *  и ?  для соответствия имен файлов. Например, чтобы найти все файлы  .txt  в каталоге с помощью  fnmatch , вы должны сделать следующее:
>>>
  >>> импорт ОС
>>> импортировать fnmatch

>>> для имени_файла в os.listdir ('some_directory /'):
... если fnmatch.fnmatch (имя_файла, '* .txt'):
... печать (имя_файла)
  
 Перебирает список файлов в  some_directory  и использует .fnmatch ()  для выполнения поиска по шаблону для файлов с расширением  .txt .
 Более расширенное сопоставление с образцом 
 Предположим, вы хотите найти  файлов .txt и  файлов, соответствующих определенным критериям. Например, вас может заинтересовать только  файлов .txt , которые содержат слово  data , число между набором знаков подчеркивания и слово  backup  в своем имени файла. Что-то похожее на  data_01_backup ,  data_02_backup  или  data_03_backup .
 Используя  fnmatch.fnmatch () , вы можете сделать это так:
>>>
  >>> для имени файла в os.listdir ('.'):
... если fnmatch.fnmatch (имя файла, 'data _ * _ backup.txt'):
... печать (имя файла)
  
 Здесь вы печатаете только имена файлов, которые соответствуют шаблону  data _ * _ backup.txt . Звездочка в шаблоне будет соответствовать любому символу, поэтому при его запуске будут найдены все текстовые файлы, имена файлов которых начинаются со слова  data  и заканчиваются резервной копией .txt , как видно из вывода ниже:
  data_03_backup.txt
data_02_backup.txt
data_01_backup.txt
  
 Сопоставление с шаблоном имени файла с использованием 
 glob 
 Еще один полезный модуль для сопоставления с образцом —  glob .
  .glob ()  в модуле  glob  работает так же, как  fnmatch.fnmatch () , но в отличие от  fnmatch.fnmatch () , он обрабатывает файлы, начинающиеся с точки (. ), как особые.
 UNIX и родственные системы переводят шаблоны имен с помощью подстановочных знаков, например ?  и  *  в список файлов. Это называется глобусом.
 Например, при вводе  mv * .py python_files /  в оболочке UNIX ( mv ) все файлы с расширением  .py  из текущего каталога в каталог  python_files . Символ  *  — это подстановочный знак, который означает «любое количество символов», а  * .py  — шаблон глобуса.Эта возможность оболочки недоступна в операционной системе Windows. Модуль  glob  добавляет эту возможность в Python, что позволяет программам Windows использовать эту функцию.
 Вот пример того, как использовать  glob  для поиска всех исходных файлов Python ( .py ) в текущем каталоге:
>>>
  >>> импорт глоб
>>> glob.glob ('*. py')
['admin.py', 'tests.py']
  
  glob.glob ('*. Py')  выполняет поиск всех файлов с .py  в текущем каталоге и возвращает их в виде списка.  glob  также поддерживает подстановочные знаки в стиле оболочки для соответствия шаблонам:
>>>
  >>> импорт глоб
>>> для имени в glob.glob ('* [0-9] *. txt'):
... печать (имя)
  
 Это находит все текстовые ( .txt ) файлы, которые содержат цифры в имени файла:
  data_01.txt
data_03.txt
data_03_backup.txt
data_02_backup.txt
data_02.txt
data_01_backup.txt
  
  glob  упрощает рекурсивный поиск файлов в подкаталогах:
>>>
  >>> импорт глоб
>>> для файла в глоб.iglob ('** / *. py', рекурсивный = True):
...     распечатать файл)
  
 В этом примере используется  glob.iglob ()  для поиска  файлов .py  в текущем каталоге и подкаталогах. Передача  recursive = True  в качестве аргумента функции  .iglob ()  заставляет ее искать файлы  .py  в текущем каталоге и любых подкаталогах. Разница между  glob.iglob ()  и  glob.glob ()  заключается в том, что  .iglob ()  возвращает итератор вместо списка.
 Выполнение указанной выше программы дает следующее:
  admin.py
tests.py
под_каталог / file1.py
подкаталог / file2.py
  
  pathlib  содержит аналогичные методы для создания гибких списков файлов. В приведенном ниже примере показано, как можно использовать  .Path.glob ()  для перечисления типов файлов, начинающихся с буквы  p :
.
 >>>
  >>> from pathlib import Path
>>> p = Путь ('.')
>>> для имени в p.glob ('*.п*'):
... печать (имя)

admin.py
scraper.py
docs.pdf
  
 Вызов  p.glob ('*. P *')  возвращает объект-генератор, который указывает на все файлы в текущем каталоге, которые начинаются с буквы  p  в их расширении.
  Path.glob ()  аналогичен  os.glob () , описанному выше. Как видите,  pathlib  сочетает в себе многие из лучших функций модулей  os ,  os.path  и  glob  в одном модуле, что делает его использование очень приятным.
 Напомним, вот таблица функций, которые мы рассмотрели в этом разделе:
 Функция
 Описание
  начинается с () 
 Проверяет, начинается ли строка с указанного шаблона и возвращает  Истина  или  Ложь 
  заканчивается с () 
 Проверяет, заканчивается ли строка указанным шаблоном и возвращает  Истина  или  Ложь 
  fnmatch.fnmatch (имя файла, шаблон) 
 Проверяет, соответствует ли имя файла шаблону и возвращает  True  или  False 
  glob.glob () 
 Возвращает список имен файлов, соответствующих шаблону
  pathlib.Path.glob () 
 Находит шаблоны в именах путей и возвращает объект-генератор
 Обход каталогов и обработка файлов 
 Обычная задача программирования — это обход дерева каталогов и обработка файлов в дереве.Давайте посмотрим, как для этого можно использовать встроенную функцию Python  os.walk () .  os.walk ()  используется для генерации имени файла в дереве каталогов путем обхода дерева сверху вниз или снизу вверх. В этом разделе мы будем работать со следующим деревом каталогов:
 .
|
├── folder_1 /
| ├── file1.py
| ├── file2.py
| └── file3.py
|
├── folder_2 /
| ├── file4.py
| ├── file5.py
| └── file6.py
|
├── test1.txt
└── test2.txt
  
 Ниже приведен пример, показывающий, как вывести список всех файлов и каталогов в дереве каталогов с помощью  os.прогулка () .
  os.walk ()  по умолчанию перемещается по каталогам сверху вниз:
  # Обход дерева каталогов и печать имен каталогов и файлов
для dirpath, dirnames, файлов в os.walk ('.'):
    print (f'Найденный каталог: {dirpath} ')
    для имя_файла в файлах:
        печать (имя_файла)
  
  os.walk ()  возвращает три значения на каждой итерации цикла:
 Имя текущей папки
 Список папок в текущей папке
 Список файлов в текущей папке
 На каждой итерации он распечатывает имена подкаталогов и файлов, которые он находит:
  Найденный каталог:.test1.txt
test2.txt
Найден каталог: ./folder_1
file1.py
file3.py
file2.py
Найден каталог: ./folder_2
file4.py
file5.py
file6.py
  
 Чтобы пройти по дереву каталогов снизу вверх, передайте аргумент ключевого слова  topdown = False  в  os.walk () :
  для dirpath, dirnames, файлов в os.walk ('.', Topdown = False):
    print (f'Найденный каталог: {dirpath} ')
    для имя_файла в файлах:
        печать (имя_файла)
  
 Передача аргумента  topdown = False  даст  os.walk ()  распечатывает файлы, которые он находит в подкаталогах , сначала :
  Найденный каталог: ./folder_1
file1.py
file3.py
file2.py
Найден каталог: ./folder_2
file4.py
file5.py
file6.py
Найден каталог:.
test1.txt
test2.txt
  
 Как видите, программа запускается с перечисления содержимого подкаталогов перед выводом содержимого корневого каталога. Это очень полезно в ситуациях, когда вы хотите рекурсивно удалить файлы и каталоги.Вы узнаете, как это сделать, в следующих разделах. По умолчанию  os.walk  не переходит к символическим ссылкам, которые разрешаются в каталоги. Это поведение можно изменить, вызвав его с аргументом  followlinks = True .
 Создание временных файлов и каталогов 
 Python предоставляет удобный модуль для создания временных файлов и каталогов под названием  tempfile .
  tempfile  можно использовать для открытия и временного хранения данных в файле или каталоге во время работы вашей программы. tempfile  обрабатывает удаление временных файлов, когда ваша программа завершает работу с ними.
 Вот как создать временный файл:
  из временного файла импорт временного файла

# Создаем временный файл и записываем в него данные
fp = временный файл ('ш + т')
fp.write ('Привет, вселенная!')

# Вернуться к началу и прочитать данные из файла
fp.seek (0)
data = fp.read ()

# Закройте файл, после чего он будет удален
fp.close ()
  
 Первым шагом является импорт  TemporaryFile  из модуля  tempfile .Затем создайте объект, подобный файлу, с помощью метода  TemporaryFile () , вызвав его и передав режим, в котором вы хотите открыть файл. Это создаст и откроет файл, который можно использовать в качестве области временного хранения.
 В приведенном выше примере используется режим  'w + t' , что заставляет  tempfile  создавать временный текстовый файл в режиме записи. Нет необходимости давать временному файлу имя файла, поскольку он будет уничтожен после завершения выполнения сценария.
 После записи в файл вы можете прочитать его и закрыть, когда закончите обработку.После закрытия файла он будет удален из файловой системы. Если вам нужно назвать временные файлы, созданные с использованием  tempfile , используйте  tempfile.NamedTemporaryFile () .
 Временные файлы и каталоги, созданные с помощью  tempfile , хранятся в специальном системном каталоге для хранения временных файлов. Python ищет в стандартном списке каталогов тот, в котором пользователь может создавать файлы.
 В Windows это каталоги  C: \ TEMP ,  C: \ TMP ,  \ TEMP  и  \ TMP  в указанном порядке.На всех других платформах каталоги  / tmp ,  / var / tmp  и  / usr / tmp  в указанном порядке. В крайнем случае,  tempfile  сохранит временные файлы и каталоги в текущем каталоге.
  .TemporaryFile ()  также является диспетчером контекста, поэтому его можно использовать вместе с оператором  with . Использование диспетчера контекста обеспечивает автоматическое закрытие и удаление файла после того, как он был прочитан:
  с TemporaryFile ('w + t') как fp:
    fp.write ('Привет, вселенная!')
    fp.seek (0)
    fp.read ()
# Файл закрыт и удален
  
 Создает временный файл и считывает из него данные. Как только содержимое файла считывается, временный файл закрывается и удаляется из файловой системы.
  tempfile  также можно использовать для создания временных каталогов. Давайте посмотрим, как это можно сделать с помощью  tempfile.TemporaryDirectory () :
>>>
  >>> импортировать временный файл
>>> с временным файлом.TemporaryDirectory () как tmpdir:
... print ('Создан временный каталог', tmpdir)
... os.path.exists (tmpdir)
...
Создан временный каталог / tmp / tmpoxbkrm6c
Правда

>>> # Содержимое каталога было удалено
...
>>> tmpdir
'/ tmp / tmpoxbkrm6c'
>>> os.path.exists (tmpdir)
Ложь
  
 Вызов  tempfile.TemporaryDirectory ()  создает временный каталог в файловой системе и возвращает объект, представляющий этот каталог. В приведенном выше примере каталог создается с помощью диспетчера контекста, а имя каталога хранится в  tmpdir .Третья строка выводит имя временного каталога, а  os.path.exists (tmpdir)  подтверждает, действительно ли каталог был создан в файловой системе.
 После того, как диспетчер контекста выходит из контекста, временный каталог удаляется, а вызов  os.path.exists (tmpdir)  возвращает  False , что означает, что каталог был успешно удален.
 Удаление файлов и каталогов 
 Вы можете удалить отдельные файлы, каталоги и целые деревья каталогов, используя методы, найденные в модулях  os ,  shutil  и  pathlib .В следующих разделах описывается, как удалить файлы и каталоги, которые вам больше не нужны.
 Удаление файлов в Python 
 Чтобы удалить один файл, используйте  pathlib.Path.unlink () ,  os.remove () . или  os.unlink () .
  os.remove ()  и  os.unlink ()  семантически идентичны. Чтобы удалить файл с помощью  os.remove () , выполните следующие действия:
  импорт ОС

data_file = 'C: \ Users \ vuyisile \ Desktop \ Test \ data.текст'
os.remove (файл_данных)
  
 Удаление файла с помощью  os.unlink ()  аналогично тому, как это делается с помощью  os.remove () :
  импорт ОС

data_file = 'C: \ Users \ vuyisile \ Desktop \ Test \ data.txt'
os.unlink (файл_данных)
  
 Вызов  .unlink ()  или  .remove ()  для файла удаляет файл из файловой системы. Эти две функции вызовут  OSError , если переданный им путь указывает на каталог, а не на файл.Чтобы избежать этого, вы можете либо проверить, что то, что вы пытаетесь удалить, на самом деле является файлом, и удалить его только в том случае, если это так, либо вы можете использовать обработку исключений для обработки ошибки  OSError :
  импорт ОС

data_file = 'главная / data.txt'

# Если файл существует, удалите его
если os.path.isfile (файл_данных):
    os.remove (файл_данных)
еще:
    print (f'Error: {data_file} недопустимое имя файла ')
  
  os.path.isfile ()  проверяет, действительно ли  data_file  является файлом.Если это так, он удаляется вызовом  os.remove () . Если  data_file  указывает на папку, на консоль выводится сообщение об ошибке.
 В следующем примере показано, как использовать обработку исключений для обработки ошибок при удалении файлов:
  импорт ОС

data_file = 'главная / data.txt'

# Использовать обработку исключений
пытаться:
    os.remove (файл_данных)
кроме OSError как e:
    print (f'Error: {data_file}: {e.strerror} ')
  
 Приведенный выше код пытается удалить файл перед проверкой его типа.Если  data_file  на самом деле не является файлом, генерируемая  OSError  обрабатывается в , за исключением предложения , и на консоль выводится сообщение об ошибке. Распечатываемое сообщение об ошибке отформатировано с использованием f-строк Python.
 Наконец, вы также можете использовать  pathlib.Path.unlink ()  для удаления файлов:
  из пути импорта pathlib

data_file = Путь ('home / data.txt')

пытаться:
    data_file.unlink ()
кроме IsADirectoryError как e:
    print (f'Error: {data_file}: {e.strerror} ')
  
 Это создает объект  Path  с именем  data_file , который указывает на файл. Вызов  .remove ()  для  data_file  удалит  home / data.txt . Если  data_file  указывает на каталог, возникает  IsADirectoryError . Стоит отметить, что указанная выше программа Python имеет те же разрешения, что и пользователь, запускающий ее. Если у пользователя нет разрешения на удаление файла, возникает ошибка  PermissionError .
 Удаление каталогов 
 Стандартная библиотека предлагает следующие функции для удаления каталогов:
  os.rmdir () 
  pathlib.Path.rmdir () 
  shutil.rmtree () 
 Чтобы удалить отдельный каталог или папку, используйте  os.rmdir ()  или  pathlib.rmdir () . Эти две функции работают, только если каталог, который вы пытаетесь удалить, пуст. Если каталог не пустой, возникает ошибка  OSError .Вот как удалить папку:
  импорт ОС

trash_dir = 'мои_документы / bad_dir'

пытаться:
    os.rmdir (trash_dir)
кроме OSError как e:
    print (f'Error: {trash_dir}: {e.strerror} ')
  
 Здесь каталог  trash_dir  удаляется путем передачи его пути в  os.rmdir () . Если каталог не пустой, на экран выводится сообщение об ошибке:
>>>
  Traceback (последний звонок последний):
  Файл '', строка 1, в 
OSError: [Errno 39] Каталог не пуст: 'my_documents / bad_dir'
  
 В качестве альтернативы вы можете использовать  pathlib  для удаления каталогов:
  из пути импорта pathlib

trash_dir = Путь ('my_documents / bad_dir')

пытаться:
    trash_dir.rmdir ()
кроме OSError как e:
    print (f'Error: {trash_dir}: {e.strerror} ')
  
 Здесь вы создаете объект  Path , который указывает на каталог, который нужно удалить. Вызов  .rmdir ()  для объекта  Path  удалит его, если он пуст.
 Удаление всех деревьев каталогов 
 Для удаления непустых каталогов и целых деревьев каталогов Python предлагает  shutil.rmtree () :
  импортный шутил

trash_dir = 'мои_документы / bad_dir'

пытаться:
    шутил.rmtree (trash_dir)
кроме OSError как e:
    print (f'Error: {trash_dir}: {e.strerror} ')
  
 Все в  trash_dir  удаляется при вызове  shutil.rmtree () . Могут быть случаи, когда вы захотите рекурсивно удалить пустые папки. Вы можете сделать это, используя один из методов, описанных выше в сочетании с  os.walk () :
  импорт ОС

для dirpath, dirnames, файлов в os.walk ('.', topdown = False):
    пытаться:
        os.rmdir (dirpath)
    кроме OSError как ex:
        проходить
  
 Это перемещается по дереву каталогов и пытается удалить каждый найденный каталог.Если каталог не пустой, возникает ошибка  OSError  и этот каталог пропускается. В таблице ниже перечислены функции, рассматриваемые в этом разделе:
 Функция
 Описание
  os.remove () 
 Удаляет файл без удаления каталогов
  os.unlink () 
 Идентичен  os.remove ()  и удаляет один файл
  pathlib.Путь.unlink () 
 Удаляет файл без возможности удаления каталогов
  os.rmdir () 
 Удаляет пустой каталог
  pathlib.Path.rmdir () 
 Удаляет пустой каталог
  shutil.rmtree () 
 Удаляет все дерево каталогов и может использоваться для удаления непустых каталогов
 Копирование, перемещение и переименование файлов и каталогов 
 Python поставляется с модулем  shutil . shutil  — это сокращение от служебных программ оболочки. Он обеспечивает ряд высокоуровневых операций с файлами для поддержки копирования, архивирования и удаления файлов и каталогов. В этом разделе вы узнаете, как перемещать и копировать файлы и каталоги.
 Копирование файлов в Python 
  shutil  предлагает несколько функций для копирования файлов. Чаще всего используются функции  shutil.copy ()  и  shutil.copy2 () . Чтобы скопировать файл из одного места в другое, используйте  shutil.copy () , выполните следующие действия:
  импортный шутил

src = 'путь / к / file.txt'
dst = 'путь / к / каталог-назначения'
shutil.copy (src, dst)
  
  shutil.copy ()  сопоставимо с командой  cp  в системах на основе UNIX.  shutil.copy (src, dst)  скопирует файл  src  в место, указанное в  dst . Если  dst  является файлом, содержимое этого файла заменяется содержимым  src . Если  dst  — это каталог, то  src  будет скопирован в этот каталог. shutil.copy ()  копирует только содержимое файла и разрешения файла. Другие метаданные, такие как время создания и изменения файла, не сохраняются.
 Чтобы сохранить все метаданные файла при копировании, используйте  shutil.copy2 () :
  импортный шутил

src = 'путь / к / file.txt'
dst = 'путь / к / каталог-назначения'
shutil.copy2 (src, dst)
  
 Использование  .copy2 ()  сохраняет сведения о файле, такие как время последнего доступа, биты прав доступа, время последнего изменения и флаги.
 Копировальные каталоги 
 В то время как  shutil.copy ()  копирует только один файл,  shutil.copytree ()  копирует весь каталог и все, что в нем содержится.  shutil.copytree (src, dest)  принимает два аргумента: исходный каталог и целевой каталог, в который будут скопированы файлы и папки.
 Вот пример того, как скопировать содержимое одной папки в другое место:
>>>
  >>> импортный шутил
>>> шутил.copytree ('данные_1', 'данные1_backup')
'data1_backup'
  
 В этом примере  .copytree ()  копирует содержимое  data_1  в новое место  data1_backup  и возвращает целевой каталог. Целевой каталог еще не должен существовать. Он будет создан вместе с отсутствующими родительскими каталогами.  shutil.copytree ()  — хороший способ сделать резервную копию ваших файлов.
 Перемещение файлов и каталогов 
 Чтобы переместить файл или каталог в другое место, используйте  shutil.переместить (src, dst) .
  src  — это файл или каталог, который нужно переместить, а  dst  — это место назначения:
>>>
  >>> импортный шутил
>>> shutil.move ('каталог_1 /', 'резервная копия /')
'резервное копирование'
  
  shutil.move ('dir_1 /', 'backup /')  перемещает  dir_1 /  в  backup / , если существует  backup / . Если  backup /  не существует,  dir_1 /  будет переименован в  backup .
 Переименование файлов и каталогов 
 Python включает  os.rename (src, dst)  для переименования файлов и каталогов:
>>>
  >>> os.rename ('first.zip', 'first_01.zip')
  
 Строка выше переименует  first.zip  в  first_01.zip . Если целевой путь указывает на каталог, это вызовет  OSError .
 Другой способ переименовать файлы или каталоги — использовать  rename ()  из модуля  pathlib :
>>>
  >>> from pathlib import Path
>>> data_file = Путь ('data_01.текст')
>>> файл_данных.rename ('data.txt')
  
 Чтобы переименовать файлы с использованием  pathlib , вы сначала создаете объект  pathlib.Path () , который содержит путь к файлу, который вы хотите заменить. Следующим шагом является вызов  rename ()  для объекта пути и передача нового имени для файла или каталога, который вы переименовываете.
 Архивирование 
 Архивы — это удобный способ упаковать несколько файлов в один. Двумя наиболее распространенными типами архивов являются ZIP и TAR.Написанные вами программы Python могут создавать, читать и извлекать данные из архивов. В этом разделе вы узнаете, как читать и писать в оба формата архивов.
 Чтение файлов ZIP 
 Модуль  zipfile  — это модуль низкого уровня, который является частью стандартной библиотеки Python.  zipfile  имеет функции, которые позволяют легко открывать и извлекать файлы ZIP. Чтобы прочитать содержимое ZIP-файла, первое, что нужно сделать, это создать объект  ZipFile .  Объекты ZipFile  аналогичны файловым объектам, созданным с помощью  open () . ZipFile  также является диспетчером контекста и поэтому поддерживает  с оператором :
  импорт zip-файла

с zipfile.ZipFile ('data.zip', 'r') как zipobj:
  
 Здесь вы создаете объект  ZipFile , передавая имя ZIP-файла для открытия в режиме чтения. После открытия ZIP-файла информация об архиве может быть доступна с помощью функций, предоставляемых модулем  zipfile . Архив  data.zip  в приведенном выше примере был создан из каталога с именем  data , который содержит всего 5 файлов и 1 подкаталог:
 .|
├── sub_dir /
| ├── bar.py
| └── foo.py
|
├── file1.py
├── file2.py
└── file3.py
  
 Чтобы получить список файлов в архиве, вызовите  namelist ()  на объекте  ZipFile :
  импорт zip-файла

с zipfile.ZipFile ('data.zip', 'r') как zipobj:
    zipobj.namelist ()
  
 Это дает список:
  ['file1.py', 'file2.py', 'file3.py', 'sub_dir /', 'sub_dir / bar.py', 'sub_dir / foo.py']
  
 .namelist ()  возвращает список имен файлов и каталогов в архиве. Чтобы получить информацию о файлах в архиве, используйте  .getinfo () :
  импорт zip-файла

с zipfile.ZipFile ('data.zip', 'r') как zipobj:
    bar_info = zipobj.getinfo ('подкаталог / bar.py')
    bar_info.file_size
  
 Вот результат:
  .getinfo ()  возвращает объект  ZipInfo , в котором хранится информация об одном элементе архива.Чтобы получить информацию о файле в архиве, вы передаете его путь в качестве аргумента  .getinfo () . Используя  getinfo () , вы можете получить информацию об элементах архива, такую ​​как дату последнего изменения файлов, их сжатые размеры и их полные имена файлов. При доступе к  .file_size  получает исходный размер файла в байтах.
 В следующем примере показано, как получить дополнительные сведения об архивных файлах в Python REPL. Предположим, что модуль  zipfile  был импортирован, а  bar_info  — это тот же объект, который вы создали в предыдущих примерах:
>>>
  >>> bar_info.date_time
(2018, 10, 7, 23, 30, 10)
>>> bar_info.compress_size
2856
>>> bar_info.filename
'sub_dir / bar.py'
  
  bar_info  содержит подробную информацию о  bar.py , такую ​​как его размер при сжатии и полный путь.
 В первой строке показано, как получить дату последнего изменения файла. В следующей строке показано, как получить размер файла после сжатия. Последняя строка показывает полный путь к  bar.py  в архиве.
  ZipFile  поддерживает протокол диспетчера контекста, поэтому вы можете использовать его с  с оператором .Это автоматически закроет объект  ZipFile  после того, как вы закончите с ним. Попытка открыть или извлечь файлы из закрытого объекта  ZipFile  приведет к ошибке.
 Создание новых ZIP-архивов 
 Чтобы создать новый ZIP-архив, откройте объект  ZipFile  в режиме записи ( w ) и добавьте файлы, которые хотите заархивировать:
>>>
  >>> импортировать zip-файл

>>> file_list = ['file1.py', 'sub_dir /', 'sub_dir / bar.py ',' sub_dir / foo.py ']
>>> с zipfile.ZipFile ('new.zip', 'w') как new_zip:
... для имени в file_list:
... new_zip.write (имя)
  
 В этом примере  new_zip  открывается в режиме записи, и каждый файл в  file_list  добавляется в архив. Когда  с набором операторов  завершается,  new_zip  закрывается. Открытие ZIP-файла в режиме записи стирает содержимое архива и создает новый архив.
 Чтобы добавить файлы в существующий архив, откройте объект  ZipFile  в режиме добавления, а затем добавьте файлы:
>>>
  >>> # Открываем объект ZipFile в режиме добавления
>>> с zip-файлом.ZipFile ('new.zip', 'a') как new_zip:
... new_zip.write ('data.txt')
... new_zip.write ('latin.txt')
  
 Здесь вы открываете архив  new.zip , созданный в предыдущем примере, в режиме добавления. Открытие объекта  ZipFile  в режиме добавления позволяет добавлять новые файлы в ZIP-файл, не удаляя его текущее содержимое. После добавления файлов в ZIP-файл оператор  с  выходит из контекста и закрывает ZIP-файл.
 Открытие архива TAR 
 Файлы
 TAR представляют собой несжатые файловые архивы, такие как ZIP.Их можно сжать с помощью методов сжатия gzip, bzip2 и lzma.  TarFile  класс позволяет читать и писать архивы TAR.
 Сделайте это, чтобы прочитать из архива:
  импортный tarfile

с tarfile.open ('example.tar', 'r') как tar_file:
    печать (tar_file.getnames ())
  
  tarfile  объекта открываются как большинство файловых объектов. У них есть функция  open () , которая принимает режим, определяющий способ открытия файла.
 Используйте режимы  'r' ,  'w'  или  'a' , чтобы открыть несжатый файл TAR для чтения, записи и добавления соответственно. Чтобы открыть сжатые файлы TAR, передайте аргумент режима  tarfile.open () , который имеет форму  filemode [: сжатие] . В таблице ниже перечислены возможные режимы открытия файлов TAR:
 Режим
 Действие
  r 
 Открывает для чтения архив с прозрачным сжатием
  r: gz 
 Открывает архив для чтения со сжатием gzip
  r: bz2 
 Открывает для чтения архив со сжатием bzip2
  r: xz 
 Открывает для чтения архив со сжатием lzma
  w 
 Открывает архив для записи без сжатия
  Вт: GZ 
 Открывает архив для записи в сжатом формате gzip
  ширина: xz 
 Открывает архив для сжатой записи lzma
  а 
 Открывает архив для добавления без сжатия
 .open ()  по умолчанию работает в режиме  'r' . Чтобы прочитать несжатый файл TAR и получить имена файлов в нем, используйте  .getnames () :
>>>
  >>> импортный tarfile

>>> tar = tarfile.open ('example.tar', mode = 'r')
>>> tar.getnames ()
['CONTRIBUTING.rst', 'README.md', 'app.py']
  
 Возвращает список с именами содержимого архива.
  Примечание:  Чтобы показать вам, как использовать различные методы объекта  tarfile , файл TAR в примерах открывается и закрывается вручную в интерактивном сеансе REPL.
 Взаимодействие с файлом TAR таким образом позволяет увидеть результат выполнения каждой команды. Обычно вы хотите использовать диспетчер контекста для открытия файловых объектов.
 К метаданным каждой записи в архиве можно получить доступ с помощью специальных атрибутов:
>>>
  >>> для ввода в tar.getmembers ():
... печать (entry.name)
... print ('Изменено:', time.ctime (entry.mtime))
... print ('Размер:', размер записи, 'байты')
...     Распечатать()
СОДЕЙСТВИЕ.первый
 Изменено: Сб, 1 ноября, 09:09:51 2018
 Размер: 402 байта

README.md
 Обновлено: 3 ноября, сб, 07:29:40 2018
 Размер: 5426 байтов

app.py
 Обновлено: 3 ноября, сб, 07:29:13 2018
 Размер: 6218 байтов
  
 В этом примере вы просматриваете список файлов, возвращаемых функцией  .getmembers () , и распечатываете атрибуты каждого файла. Объекты, возвращаемые функцией  .getmembers () , имеют атрибуты, к которым можно получить доступ программно, например имя, размер и время последнего изменения каждого из файлов в архиве.После чтения или записи в архив его необходимо закрыть, чтобы освободить ресурсы системы.
 Создание новых архивов TAR 
 Вот как это сделать:
>>>
  >>> импортный tarfile

>>> file_list = ['app.py', 'config.py', 'CONTRIBUTORS.md', 'tests.py']
>>> с tarfile.open ('packages.tar', mode = 'w') как tar:
... для файла в file_list:
... tar.add (файл)

>>> # Прочитать содержимое только что созданного архива
>>> с tarfile.open ('package.tar', mode = 'r') как t:
... для члена t.getmembers ():
... печать (имя члена)
app.py
config.py
CONTRIBUTORS.md
tests.py
  
 Сначала вы составляете список файлов, которые нужно добавить в архив, чтобы вам не приходилось добавлять каждый файл вручную.
 Следующая строка использует  с диспетчером контекста  для открытия нового архива с именем  packages.tar  в режиме записи. Открытие архива в режиме записи ( 'w' ) позволяет вам записывать в архив новые файлы.Все существующие файлы в архиве удаляются, и создается новый архив.
 После создания и заполнения архива  с менеджером контекста  автоматически закрывает его и сохраняет в файловой системе. Последние три строки открывают только что созданный архив и распечатывают имена содержащихся в нем файлов.
 Чтобы добавить новые файлы в существующий архив, откройте архив в режиме добавления ( 'a' ):
>>>
  >>> с tarfile.open ('package.tar', mode = 'a') как tar:
... tar.add ('foo.bar')

>>> с tarfile.open ('package.tar', mode = 'r') как tar:
... для члена tar.getmembers ():
... печать (имя члена)
app.py
config.py
CONTRIBUTORS.md
tests.py
foo.bar
  
 Открытие архива в режиме добавления позволяет добавлять в него новые файлы, не удаляя уже существующие.
 Работа со сжатыми архивами 
  tarfile  также может читать и записывать архивы TAR, сжатые с использованием сжатия gzip, bzip2 и lzma.Для чтения или записи в сжатый архив используйте  tarfile.open () , передав режим, соответствующий типу сжатия.
 Например, для чтения или записи данных в архив TAR, сжатый с помощью gzip, используйте режимы  'r: gz'  или  'w: gz'  соответственно:
>>>
  >>> files = ['app.py', 'config.py', 'tests.py']
>>> с tarfile.open ('packages.tar.gz', mode = 'w: gz') как tar:
... tar.add ('app.py')
... tar.add ('config.ру ')
... tar.add ('tests.py')

>>> с tarfile.open ('packages.tar.gz', mode = 'r: gz') как t:
... для члена t.getmembers ():
... печать (имя члена)
app.py
config.py
tests.py
  
 Режим  'w: gz'  открывает архив для записи со сжатием gzip, а  'r: gz'  открывает архив для чтения со сжатием gzip.
 Открытие сжатых архивов в режиме добавления невозможно. Чтобы добавить файлы в сжатый архив, вам необходимо создать новый архив.
 Более простой способ создания архивов 
 Стандартная библиотека Python также поддерживает создание архивов TAR и ZIP с использованием высокоуровневых методов модуля  shutil .Утилиты архивирования в  shutil  позволяют создавать, читать и извлекать архивы ZIP и TAR. Эти утилиты полагаются на модули нижнего уровня  tarfile  и  zipfile .
  Работа с архивами с использованием  shutil.make_archive ()  
  shutil.make_archive ()  принимает как минимум два аргумента: имя архива и формат архива.
 По умолчанию он сжимает все файлы в текущем каталоге в формат архива, указанный в аргументе  формат .Вы можете передать необязательный аргумент  root_dir  для сжатия файлов в другом каталоге.  .make_archive ()  поддерживает форматы архивов  zip ,  tar ,  bztar  и  gztar .
 Вот как создать архив TAR с использованием  shutil :
  импортный шутил

# shutil.make_archive (базовое_имя, формат, корневой_каталог)
shutil.make_archive ('данные / резервная копия', 'tar', 'данные /')
  
 Это копирует все в  data /  и создает архив под названием  backup.tar  в файловой системе и возвращает его имя. Чтобы распаковать архив, вызовите  .unpack_archive () :
  shutil.unpack_archive ('backup.tar', 'extract_dir /')
  
 Вызов  .unpack_archive ()  и передача имени архива и каталога назначения извлекает содержимое  backup.tar  в  extract_dir / . ZIP-архивы можно создавать и извлекать таким же образом.
 Чтение нескольких файлов 
 Python поддерживает чтение данных из нескольких входных потоков или из списка файлов через модуль  fileinput .Этот модуль позволяет быстро и легко перебирать содержимое одного или нескольких текстовых файлов.
 Вот типичный способ использования  fileinput :
  импорт файла ввода
для строки в fileinput.input ()
    процесс (линия)
  
  fileinput  получает входные данные из аргументов командной строки, переданных в  sys.argv  по умолчанию.
  Использование  fileinput  для перебора нескольких файлов 
 Давайте воспользуемся  fileinput  для создания грубой версии общей утилиты UNIX  cat .Утилита  cat  последовательно читает файлы, записывая их на стандартный вывод. Если в аргументах командной строки указано более одного файла,  cat  объединит текстовые файлы и отобразит результат в терминале:
  # Файл: fileinput-example.py
импортировать файл
import sys

files = fileinput.input ()
для строки в файлах:
    если fileinput.isfirstline ():
        print (f '\ n --- Чтение {fileinput.filename ()} ---')
    print ('->' + строка, конец = '')
Распечатать()
  
 Выполнение этого для двух текстовых файлов в моем текущем каталоге дает следующий результат:
  $ python3 fileinput-example.py bacon.txt cupcake.txt
--- Чтение bacon.txt ---
 -> Пряный халапеньо бекон ipsum dolor amet in aute est qui enim aliquip,
 -> irure cillum голень elit.
 -> Doner jowl shank ea упражнение landjaeger incididunt ut porchetta.
 -> Вырезка бекона аликвип купидатат курица цыпленок quis anim et свинья.
 -> Донер с тремя наконечниками, кевин силлум, ветчина, вениам, коровий гамбургер.
 -> Индейка свиная корейка купидатат филе миньон капикола грудинка купим объявление в.
 -> Ball tip dolor do magna labouris nisi pancetta nostrud doner.--- Чтение cupcake.txt ---
 -> Кекс ipsum dolor sit amet candy Я люблю чизкейк кекс.
 -> Посыпать кекс сахарной ватой.
 -> Жевательные конфеты макаруны марципановые марципановые марципаны марципановые марципаны марципановые мармеладки.
  
  fileinput  позволяет получить дополнительную информацию о каждой строке, например, является ли она первой строкой ( .isfirstline () ), номером строки ( .lineno () ) и именем файла (. имя файла () ). Вы можете прочитать больше об этом здесь.
 Заключение 
 Теперь вы знаете, как использовать Python для выполнения наиболее распространенных операций с файлами и группами файлов.Вы узнали о различных встроенных модулях, используемых для чтения, поиска и управления ими.
 Теперь вы готовы использовать Python для:
 Получить содержимое каталога и свойства файла
 Создание каталогов и деревьев каталогов
 Найти шаблоны в именах файлов
 Создание временных файлов и каталогов
 Перемещение, переименование, копирование и удаление файлов или каталогов
 Чтение и извлечение данных из архивов разных типов
 Чтение нескольких файлов одновременно с использованием файлового входа  
 6.Модули — документация Python 3.10.0 
 >>> import builtins
>>> dir (встроенные)
['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
 BlockingIOError, BrokenPipeError, BufferError, BytesWarning,
 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError',
 ConnectionRefusedError, ConnectionResetError, DeprecationWarning,
 EOFError, Ellipsis, EnvironmentError, Exception, False,
 FileExistsError, FileNotFoundError, FloatingPointError,
 FutureWarning, GeneratorExit, IOError, ImportError,
 ImportWarning, IndentationError, IndexError, InterruptedError,
 IsADirectoryError, KeyError, KeyboardInterrupt, LookupError,
 MemoryError, NameError, None, NotADirectoryError, NotImplemented,
 NotImplementedError, OSError, OverflowError,
 PendingDeprecationWarning, PermissionError, ProcessLookupError,
 ReferenceError, ResourceWarning, RuntimeError, RuntimeWarning,
 StopIteration, SyntaxError, SyntaxWarning, SystemError,
 SystemExit, TabError, TimeoutError, True, TypeError,
 UnboundLocalError, UnicodeDecodeError, UnicodeEncodeError,
 UnicodeError, UnicodeTranslateError, UnicodeWarning, UserWarning,
 'ValueError', 'Предупреждение', 'ZeroDivisionError', '_', '__build_class__',
 '__debug__', '__doc__', '__import__', '__name__', '__package__', 'abs',
 all, any, ascii, bin, bool, bytearray, bytes, callable,
 chr, classmethod, compile, complex, copyright, credits,
 delattr, dict, dir, divmod, enumerate, eval, exec, exit,
 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr',
 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass',
 iter, len, лицензия, list, locals, map, max, memoryview,
 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'свойство',
 'quit', 'range', 'repr', 'reverse', 'round', 'set', 'setattr', 'срез',
 'sorted', 'staticmethod', 'str', 'sum', 'super', 'кортеж', 'type', 'vars',
 'zip']
 
 В ‘b’ или не в ‘b’ — открытие файлов в Python 3 
 Недавно мы начали переводить наш код с Python 2 на Python 3.Процесс в основном прошел гладко, так как большая часть кода работает одинаково в обеих версиях. Однако есть пара серьезных изменений, которые не позволяют коду Python 2 работать в Python 3. Этот пост относится к одному конкретному случаю этого, при чтении и записи текстовых файлов с входами и выходами.
 По общему признанию, мы не очень разбираемся в коде и не всегда применяем правильные методы. Я узнал об этой разнице в чтении и записи файлов не из предварительных исследований перед миграцией, а просто попытавшись запустить старый код Python 2 в Python 3.
 Для чтения и записи строк мы бы использовали «rb» и «wb» в Python 2, но выполнение того же самого в Python 3 вызывает всевозможные ошибки. Использование «r» и «w» вместо этого решает эти проблемы, но я хотел копнуть глубже, чтобы понять, что мы делали неправильно.
 Проблема 
 Это:
 с open ('test.txt', 'w') как f:
    text = f.write ('это тестовая строка')
 
 работает.
 А вот это:
 с открытым ('test.txt ',' wb ') как f:
    text = f.write ('это тестовая строка')
 
 выдает эту ошибку:
 TypeError: требуется объект, подобный байтам, а не str
 
 Однако оба работают на Python 2.
 Аналогично, это:
 с open ('test.txt', 'r') как f:
    текст = f.read ()
печать (текст)
print (text == 'это тестовая строка')
 
 возвращает:
 это тестовая строка
Правда
 
 А вот это:
 с открытым ('test.txt ',' rb ') как f:
    текст = f.read ()
печать (текст)
print (text == 'это тестовая строка')
 
 возвращает:
 b'это тестовая строка '
Ложь
 
 Опять же, на Python 2 будет работать либо «r», либо «rb».
 Из вывода вы можете видеть, что Python 3 обрабатывает строки по-разному, ожидая ввода байтов и создавая вывод байтов, когда ‘b’ добавляется к ‘r’ или ‘w’ (b для двоичного режима и без b, текстовый режим) . Однако Python 2 каким-то образом может обрабатывать строковый ввод и может независимо устанавливать вывод в виде строки.
 Что происходит? 
 Ссылаясь на официальную документацию Python2 по чтению и записи файлов с входами и выходами, аргумент, следует ли добавлять «b»:
 В Windows  'b' , добавленное к режиму, открывает файл в двоичном режиме, поэтому есть также такие режимы, как  'rb' ,  'wb'  и  'r + b' . Python в Windows делает различие между текстовыми и двоичными файлами; : символы конца строки в текстовых файлах автоматически слегка изменяются при чтении или записи данных. Эта негласная модификация файловых данных подходит для текстовых файлов ASCII, но приведет к повреждению двоичных данных, как в файлах  JPEG  или  EXE . Будьте очень осторожны при чтении и записи таких файлов в двоичном режиме.  В Unix не повредит добавить  'b'  к режиму, так что вы можете использовать его независимо от платформы для всех двоичных файлов. 
 Таким образом, очевидно, что за кулисами творится какая-то магия, и для текстовых файлов двоичный режим был бы своего рода уловкой, которая позволила бы коду работать на любой платформе.
 Однако в официальной документации Python 3 по чтению и записи файлов с входами и выходами сказано:
 Обычно файлы открываются в текстовом режиме  , это означает, что вы читаете и записываете строки из файла и в файл, которые закодированы в определенной кодировке. Если кодировка не указана, значение по умолчанию зависит от платформы (см.  open () ).  'b' , добавленный к режиму, открывает файл  в двоичном режиме :  теперь данные читаются и записываются в виде байтовых объектов .Этот режим следует использовать для всех файлов, не содержащих текста.
 Таким образом, текстовый режим (без «b») следует использовать при чтении и записи текстовых файлов.
 Заключение 
 Я думаю, что могу понять, что происходит в Python 3, и это  звучит  интуитивно. Двоичный режим читает и записывает байты, текстовый режим читает и записывает текст. Но после того, как я узнал об этом, я немного запутался в том, что Python 2 делал, чтобы справиться с этим. В любом случае, урок извлечен из того, что один и тот же код может не работать в разных версиях Python, и следует проявлять больше осторожности при миграции, прежде чем произойдет ошибка с более серьезными последствиями.Возможно, я не прав в приведенном выше анализе, поэтому не стесняйтесь вносить свой комментарий ниже! Хотел бы узнать об этом больше. Ваше здоровье!
 Обработка файлов в Python — GeeksforGeeks 
 Python также поддерживает обработку файлов и позволяет пользователям обрабатывать файлы, то есть читать и записывать файлы, а также многие другие параметры обработки файлов для работы с файлами. Концепция обработки файлов распространилась на различные другие языки, но реализация либо сложна, либо длинна, но, как и другие концепции Python, эта концепция здесь также проста и коротка.Python по-разному трактует файл как текстовый или двоичный, и это важно. Каждая строка кода включает последовательность символов, и они образуют текстовый файл. Каждая строка файла заканчивается специальным символом, который называется EOL или символом конца строки, например запятой {,} или символом новой строки. Он завершает текущую строку и сообщает интерпретатору, что началась новая. Начнем с чтения и записи файлов.
  Работа функции open () 
 Мы используем функцию  open ()  в Python, чтобы открыть файл в режиме чтения или записи.Как объяснялось выше, open () вернет файловый объект. Чтобы вернуть объект файла, мы используем функцию  open ()  вместе с двумя аргументами, которые принимают имя файла и режим, читать или писать. Итак, синтаксис:  open (имя файла, режим) . Python предоставляет три режима и способы открытия файлов:
 « r » для чтения.
 « w », для письма.
 « a », для добавления.
 « r + », как для чтения, так и для записи
 Следует иметь в виду, что аргумент режима не является обязательным.Если не передано, Python по умолчанию примет значение « r ». Давайте посмотрим на эту программу и попробуем проанализировать, как работает режим чтения:
  файл   =   открыть   (  'geek.txt'  ,   'r'  ) 
  для   каждый   в   файл  : 
    печать   (каждый) 
 Команда открытия открывает файл в цикл будет печатать каждую строку, присутствующую в файле.
  Работа в режиме чтения () 
 Существует несколько способов чтения файла в Python. Если вам нужно извлечь строку, содержащую все символы в файле, мы можем использовать  file.read () . Полный код будет работать так:
  файл   =   открыть   (  "файл.текст"  ,   "r"  ) 
  печать (  файл  .read ()) 
 Другой способ прочитать файл — вызвать определенное количество символов, как в следующем коде, интерпретатор прочитает первые пять символов сохраненных данных и вернет их в виде строки:
  файл   =   открыть   (  "файл.txt"  ,   "r"  ) 
  печать   (  файл.  чтение (  5  )) 
  Создание файла с использованием режима записи () 
 Давайте посмотрим, как создать файл и как работает режим записи: 
 Чтобы управлять файлом, напишите следующее в вашей среде Python:
  файл   =   открыть   (  'geek.txt'  ,   'w'  ) 
  файл.write (  «Это команда записи»  ) 
  файл   .write (  «Это позволяет нам писать в конкретный файл»  ) 
  файл   .close ( ) 
 Команда close () завершает работу всех используемых ресурсов и освобождает систему от этой конкретной программы.
  Работа режима append () 
 Давайте посмотрим, как работает режим добавления:
  файл   =   открыть   (  'geek.txt ' ,  ' a ' ) 
  файл   .write (  "Это добавит эту строку"  ) 
  файл   .close ()
31
 Существуют также различные другие команды для обработки файлов, которые используются для обработки различных задач, например:
 rstrip (): Эта функция удаляет каждую строку файла из пробелов с правой стороны.
lstrip (): эта функция удаляет каждую строку файла с левой стороны.
 Он разработан для обеспечения более чистого синтаксиса и обработки исключений при работе с кодом. Это объясняет, почему рекомендуется использовать их с утверждениями, где это применимо. Это полезно, потому что при использовании этого метода любые открытые файлы будут автоматически закрыты после того, как один будет выполнен, поэтому автоматическая очистка. 
 Пример:
  с   открытым   (  "file.txt"  ) как   файл  : 
    файл данных   =   файл данных .read () 
  Использование записи вместе с функцией with () 
 Мы также можем использовать функцию записи вместе с функцией with ():
  с   открытыми   (  "file.txt"  ,   "w"  ) as f: 
    f.write (  "Hello World !!!"  ) 
 900 split () с использованием обработки файлов 
 Мы также можем разделить строки с помощью обработки файлов в Python.Это разбивает переменную, когда встречается пробел. Вы также можете разделить, используя любые символы, как пожелаете. Вот код:
  с   открыто   (  "файл.текст"  ,   "r"  ) как   файл 
0003: 
  data   =   файл   .readlines () 
    для   строка   в   data: 
    word   =   строка.split () 
    print   (word) 
 Существуют также различные другие функции, которые помогают управлять файлами и их содержимым. Можно изучить различные другие функции в Документах Python.
 Эту статью предоставил  Чинмой Ленка . Если вам нравится GeeksforGeeks, и вы хотели бы внести свой вклад, вы также можете написать статью на сайте deposit.geeksforgeeks.org или отправить свою статью по почте @ geeksforgeeks.орг. Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам.
 Пожалуйста, напишите комментарий, если вы обнаружите что-то неправильное, или если вы хотите поделиться дополнительной информацией по теме, обсужденной выше.
 Внимание компьютерщик! Укрепите свои основы с помощью курса  Python Programming Foundation  и изучите основы.
 Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса  Python DS . И чтобы начать свое путешествие по машинному обучению, присоединяйтесь к курсу  Машинное обучение — базовый уровень 
 Как эффективно читать текстовый файл в 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' 
 Открыть текстовый файл для чтения текста
  'w '
 Открыть текстовый файл для ввода текста
 ' 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.
 Вы нашли это руководство полезным?
 Встроенные изменения функций — документация Conservative Python 3 Porting Guide 1.0 
 Python 3 претерпел некоторые изменения во встроенных функциях.Эти изменения подробно описаны в этом разделе.
 Функция 
 print () 
 Fixer:  python-modernize -wnf libmodernize.fixes.fix_print 
 Распространенность: очень часто
 До того, как Python впервые представил аргументы ключевого слова и даже функции с
 переменное количество аргументов, у него был оператор  print .
 Он работал для простых случаев использования, но приобрел особый синтаксис для продвинутых
 такие функции, как (не) конечные строки и вывод в произвольные файлы:
 напечатайте 'a + b =',
напечатать a + b
печать >> sys.stderr, 'Вычислил сумму'
 
 В Python 3 этот оператор отсутствует. Вместо этого вы можете использовать  print () 
  функция , которая имеет четкую семантику (но требует дополнительной пары
 круглые скобки в общем случае):
 print ('a + b =', конец = '')
печать (a + b)
print ('Вычислили сумму', file = sys.stderr)
 
 Функциональная форма  print  доступна в Python 2.6+, но для ее использования
 форма выписки должна быть отключена с будущим импортом:
 из __future__ import print_function
 
 Рекомендуемый фиксатор добавит будущий импорт и перепишет все использования
 из  отпечаток .
 Сейф 
 вход () 
 Fixer:  python-modernize -wnf libmodernize.fixes.fix_input_six 
 Распространенность: Необычный
 В Python 2 функция  input ()  считывает строку из стандартного ввода,
  оценил его как код Python  и вернул результат.
 Это почти никогда не бывает полезным — от большинства пользователей не ожидается, что они знают синтаксис Python.
 Это также угроза безопасности, поскольку позволяет пользователям запускать произвольный код.
 Python 2 также имел нормальную версию  raw_input () , которая считывала строку и
 вернул его как строку.
 В Python 3  input ()  имеет нормальную семантику, а  raw_input  был
 удаленный.
 Библиотека совместимости: шесть библиотек включают помощник,  six.moves.input , который имеет
 Семантика Python 3 в обеих версиях.
 Рекомендуемый фиксатор импортирует этот помощник как  вход , замените
  raw_input (...)  на  input (...) , и заменить  input (...)  на
  eval (вход (...)) .
 После его запуска проверьте вывод, чтобы определить, есть ли  eval () 
 выдает действительно нужно.
 Удалено 
 файла () 
 Fixer:  python-modernize -wnf libmodernize.fixes.fix_file  (но см. Ниже)
 Распространенность: Редко
 В Python 2  file ()  был типом открытого файла. Он использовался в двух
 способы:
 Для открытия файлов, т.е. как псевдоним для  open () . В документации упоминается
 что  open  больше подходит для этого случая.
 Чтобы проверить, является ли объект файлом, как в  isinstance (f, file) .
 Рекомендуемый фиксатор предназначен для первого использования: он перепишет все вызовы в
  файл () с  по  открыть () .
 Если ваш код использует имя  файл  для другой функции, вам понадобится
 чтобы отменить изменение фиксатора.
 Исправитель не рассматривает второй случай. Есть много видов файловых
 объекты в Python; в большинстве случаев лучше проверить
 метод  read  или  write  вместо запроса типа.
 В разделе этого руководства, посвященном строкам, даже рекомендуется использовать
 библиотека  io , чья функция  open  создает файловые объекты, которые
 не относятся к типу  файла .
 Если необходима проверка типов файлов, мы рекомендуем использовать кортеж типов.
 который включает  io.IOBase  и, в Python 2, файл  :
 импорт io

пытаться:
    # Python 2: "файл" встроен
    file_types = файл, io.IOBase
кроме NameError:
    # Python 3: "файл" полностью заменен на IOBase
    file_types = (io.IOBase,)

...
isinstance (f, типы_файлов)
 
 Удалено 
 применить () 
 Fixer:  python-modernize -wnf fissix.fixes.fix_apply  (но см. ниже)
 Распространенность: Обычный
 В Python 2 встроена функция  apply () .
 Это было полезно до того, как Python добавил поддержку передачи списка аргументов.
 в функцию через синтаксис  * .
 Код:
 аргументов = [7, 3]
применить (сложный, аргументы)
 
 можно заменить на:
 аргументов = [7, 3]
сложный (* аргументы)
 
 Рекомендуемое средство исправления заменяет все вызовы  применить  с новым синтаксисом.Если применяется переменная ,  называет другую функцию
 в некоторых модулях отмените изменения, внесенные исправлением в этом модуле.
 Перемещено 
 уменьшить () 
 Fixer:  python-modernize -wnf fissix.fixes.fix_reduce 
 Распространенность: Необычный
 В Python 2 встроена функция  reduce () .
 В Python 3, чтобы уменьшить количество встроенных функций, он был перемещен
 к модулю  functools .
 Новое местоположение также доступно в Python 2.6+, так что это удаление можно исправить
 импортировав его для всех версий Python:
 из functools import reduce
 
 Рекомендуемый установщик добавит этот импорт автоматически.
 Функция 
 exec () 
 Fixer:  python-modernize -wnf fissix.fixes.fix_exec 
 Распространенность: Редко
 В Python 2  exec ()  было оператором. В Python 3 это функция.
 Было три случая для формы заявления  exec :
 exec some_code
exec some_code в глобальных переменных
exec some_code в глобальных, локальных
 
 Аналогично, функция  exec  принимает от одного до трех аргументов:
 exec (некоторый_код)
exec (some_code, глобальные переменные)
exec (some_code, глобальные, локальные)
 
 В Python 2 синтаксис был расширен, поэтому первое выражение может быть
 2 или 3 кортежа.Это означает, что подобный функциям синтаксис работает даже в Python 2.
 Рекомендуемый фиксатор преобразует все варианты использования  exec  в функционально-подобные.
 синтаксис.
 Удалено 
 execfile () 
 Фиксатор: не рекомендуется
 Распространенность: очень редко
 Python 2 включал функцию  execfile () , которая выполняла
 файл Python по имени.
 Звонок:
 примерно соответствовал:
 из io import open

def compile_file (имя файла):
    с open (имя файла, кодировка = 'utf-8') как f:
        возврат компиляции (ф.чтение (), имя файла, 'exec')

exec (файл_компиляции (имя файла))
 
 Если в вашем коде используется  execfile , добавьте указанную выше функцию  compile_file  в
 подходящее место, затем измените все вызовы с  execfile  на  exec 
 как указано выше.
 Хотя в Automated fixer: python-modernize есть средство исправления  execfile , мы не рекомендуем
 используя его, так как он неправильно закрывает файл.
 Обратите внимание, что приведенное выше жестко кодирует кодировку  utf-8  (которая также работает, если ваш
 код использует ASCII).Если в вашем коде используется другая кодировка, замените ее.
 Если вы не знаете кодировку заранее, вам нужно будет соблюдать PEP 263.
 специальные комментарии: на Python 3 используйте указанное выше с  tokenize.open () 
 вместо  open () , а на Python 2 вернуться к старому
  execfile () .
 Функция  io.open ()  обсуждается в этом руководстве.
 раздел по струнам.
 Перемещено 
 перезарядка () 
 Фиксатор: Нет
 Распространенность: очень редко
 Функция  reload ()  была встроена в Python 2.В Python 3 он перемещен в модуль  importlib .
 Python 2.7 включал модуль  importlib , но без функции  reload .
 В Python 2.6 и ниже не было модуля  importlib .
 Если в вашем коде используется  reload () , импортируйте его условно, если он не существует
 (с использованием функции обнаружения):
 попробовать:
    # Python 2: "перезагрузка" встроена
    перезагрузить
кроме NameError:
    из importlib import reload
 
 Переехал 
 стажер () 
 Фиксатор: Нет
 Распространенность: очень редко
 Функция  intern ()  была встроена в Python 2.В Python 3 он перемещен в модуль  sys .
 Если в вашем коде используется  intern () , импортируйте его условно, если он не существует
 (с использованием функции обнаружения):
 попробовать:
    # Python 2: "стажер" встроен
    стажер
кроме NameError:
    от sys import intern
 
 Удалено 
 coerce () 
 Фиксатор: Нет
 Распространенность: Редко
 Python 3 удаляет устаревшую функцию  coerce () , которая была только
 полезно в ранних версиях Python.
 Если ваш код использует его, измените код, чтобы он не требовался.
 Если какой-либо из ваших классов определяет специальный метод  __coerce__ ,
 удалите и это, и проверьте, что удаление не нарушило семантику.
 Учебное пособие по
 Python: Управление файлами 
 «Как попасть в рассол» 
 На самом деле мы не имеем в виду то, что написано в заголовке. Напротив, мы хотим предотвратить любую неприятную ситуацию, например потерю данных, рассчитанных вашей программой Python.Итак, мы покажем вам, как вы можете легко сохранить свои данные, чтобы вы или, лучше, ваша программа могла повторно прочитать их позже. Мы «травим» данные, чтобы ничего не потерялось.
 Python предлагает для этой цели модуль, который называется «pickle». С помощью алгоритмов модуля pickle мы можем сериализовать и десериализовать структуры объектов Python. «Обработка» обозначает процесс, который преобразует иерархию объектов Python в поток байтов, а «выделение», с другой стороны, является обратной операцией, т.е.е. поток байтов преобразуется обратно в иерархию объектов. То, что мы называем травлением (и распаковкой), также известно как «сериализация» или «выравнивание» структуры данных.
 Объект может быть выгружен методом дампа модуля pickle:
 pickle.dump (obj, file [, protocol, *, fix_imports = True]) 
 dump () записывает обработанное представление obj в объектный файл открытого файла. Необязательный аргумент протокола указывает сборщику использовать данный протокол:
 Протокол версии 0 является исходным (до Python3) удобочитаемым (ascii) протоколом и обратно совместим с предыдущими версиями Python.
 Протокол
 версии 1 — это старый двоичный формат, который также совместим с предыдущими версиями Python.
 Протокол
 версии 2 был представлен в Python 2.3. Он обеспечивает гораздо более эффективное «консервирование» классов нового стиля.
 Протокол
 версии 3 был представлен в Python 3.0. Он имеет явную поддержку байтов и не может быть извлечен модулями pickle Python 2.x. Это рекомендуемый протокол Python 3.x.
 Протокол Python3 по умолчанию — 3.
 Если fix_imports имеет значение True и протокол меньше 3, pickle попытается сопоставить новые имена Python3 со старыми именами модулей, используемыми в Python2, чтобы поток данных pickle был доступен для чтения с помощью Python 2.
 Объекты, которые были выгружены в файл с помощью pickle.dump, могут быть перечитаны в программе с помощью метода pickle.load (file). pickle.load автоматически распознает, какой формат был использован для записи данных.
 Простой пример:
импортный рассол

cities = ["Париж", "Дижон", "Лион", "Страсбург"]
fh = open ("data.pkl", "bw")
pickle.dump (города, fh)
fh.close () 
 Файл data.pkl может быть снова прочитан Python в том же или другом сеансе или другой программой:
импортный рассол
f = open ("данные.пкл »,« рб »)
villes = pickle.load (е)
печать (villes)
["Париж", "Дижон", "Лион", "Страсбург"]
 
 Сохраняются только объекты, а не их имена. Вот почему мы используем присвоение villes в предыдущем примере, т.е. data = pickle.load (f).
 В нашем предыдущем примере мы выбрали только один объект, то есть список французских городов. Но как насчет травления нескольких объектов? Решение простое: мы упаковываем объекты в другой объект, поэтому нам нужно будет снова засолить один объект.Мы упакуем два списка «programming_languages» и «python_dialects» в список pickle_objects в следующем примере:
импортный рассол
fh = open ("data.pkl", "bw")
программирование_languages ​​= ["Python", "Perl", "C ++", "Java", "Lisp"]
python_dialects = ["Jython", "IronPython", "CPython"]
pickle_object = (программирование_языков, python_dialects)
pickle.dump (pickle_object, fh)
fh.close ()
 
 Консервированные данные из предыдущего примера, то есть данные, которые мы записали в файл data.pkl, — снова можно разделить на два списка, когда мы перечитаем данные:
 импортный рассол
 f = open («data.pkl», «rb»)
 языки, диалекты) = pickle.load (f)
 печать (языки, диалекты)
 [Python, Perl, C ++, Java, Lisp] [Jython, IronPython, CPython]
 полочный модуль 
 Один из недостатков модуля травления заключается в том, что он способен протравливать только один объект за один раз, который необходимо распаковать за один раз. Представим, что этот объект данных является словарем.Может быть желательно, чтобы нам не нужно было каждый раз сохранять и загружать весь словарь, а сохранять и загружать только одно значение, соответствующее только одному ключу. Модуль полки — решение этого запроса. «Полка», используемая в модуле полки, представляет собой постоянный объект, подобный словарю. Разница с базами данных dbm состоит в том, что значения (не ключи!) На полке могут быть по существу произвольными объектами Python — всем, что может обрабатывать модуль «pickle». Это включает в себя большинство экземпляров классов, рекурсивных типов данных и объектов, содержащих множество общих подобъектов.Ключи должны быть строками.
 Модуль полки можно легко использовать. На самом деле это так же просто, как использовать словарь в Python. Прежде чем мы сможем использовать объект полки, мы должны импортировать модуль. После этого мы должны открыть объект полки с открытым методом полки. Открытый метод открывает специальный файл полки для чтения и записи:
 импортная полка
 s = shelve.open («MyShelve»)
 Если файл «MyShelve» уже существует, метод open попытается открыть его.Если это не файл полки, то есть файл, созданный с помощью модуля полки, мы получим сообщение об ошибке. Если файл не существует, он будет создан.
 Мы можем использовать s как обычный словарь, если мы используем строки в качестве ключей:
s ["street"] = "Fleet Str"
s ["city"] = "Лондон"
для ввода s:
    печать (ключ) 
 .
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Комментарий *
Имя * 
Email * 
Сайт