Взаимодействие с файловой системой#
Нередко требуется программными средствами взаимодействовать с файловой системой и в стандартной библиотеке python реализовано много инструментов, значительно упрощающих этот процесс.
Путь к файлу/директории#
Путь (англ. path) — набор символов, показывающий расположение файла или каталога в файловой системе (источник — wikipedia). В программных средах путь необходим, например, для того, чтобы открывать и сохранять файлы. В большинстве случаев в python путь представляется в виде обычного строкового объекта.
Обычно путь представляет собой последовательность вложенных каталогов, разделенных специальным символом, при этом разделитель каталогов может меняться в зависимости от операционной системы: в OS Windows используется “\”, в unix-like системах — “/”. Кроме того, важно знать, что пути бывают абсолютными и относительными. Абсолютный путь всегда начинается с корневого каталога файловой системы (в OS Windows — это логический раздел (например, “C:”), в UNIX-like системах — “/”) и всегда указывает на один и тот же файл (или директорию). Относительный путь, наоборот, не начинается с корневого каталога и указывает расположение относительно текущего рабочего каталога, а значит будет указывать на совершено другой файл, если поменять рабочий каталог.
Итого, например, путь к файлу “hello.py” в домашней директории пользователя “ivan” в зависимости от операционной системы будет выглядеть приблизительно следующим образом:
|
|
|
|
|---|---|---|
|
Глобальный |
C:\Users\ivan\hello.py |
/home/users/ivan/hello.py |
|
Относительный |
.\hello.py |
./hello.py |
В связи с этим требуется прикладывать дополнительные усилия, чтобы заставить работать один и тот же код на машинах с разными операционными системами. Чтобы все же абстрагироваться от того, как конкретно устроена файловая система на каждой конкретной машине, в python предусмотренны модули стандартной библиотеки os.path и pathlib.
Проблема с путями в стиле Windows#
Как было отмечено выше, в Windows в качестве разделителя используется символ обратного слеша (backslash) “\”. Это может привести к небольшой путанице у неопытных программистов. Дело в том, что во многих языка программирования (и в python, в том числе) символ “\” внутри строк зарезервирован для экранирования, т.е. если внутри строки встречается “ “, то он интерпретируется не буквально как символ обратного слеша, а изменяет смысл следующего за ним символом. Так, например, последовательность "\n" представляет собой один управляющий символ перевода строки.
new_line = "\n" print(len(new_line))
Это значит, что если вы попробуете записать Windows путь не учитывая эту особенность, то высока вероятность получить не тот результат, который вы ожидали. Например, строка "C:\Users" вообще не корректна с точки зрения синтаксиса python:
users_folder = "C:\Users"
Input In [10] users_folder = "C:\Users" ^ SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \UXXXXXXXX escape
Это объясняется тем, что последовательность "\U" используется для экранирования unicode последовательностей, а набор символов "sers" не является корректным unicode кодом. Ниже приводится пример корректного unicode кода.
snake_emoji = "\U0001F40D" print(snake_emoji)
В python предусмотренно как минимум два подхода борьбы с этой проблемой.
Первый из них опирается на удвоение количества символов “\”. Дело в том, что в последовательности символов “\\” — первый обратный слеш экранирует второй, т.е. итоговый результат эквивалентен одному настоящему символу обратного слеша.
users_folder = "C:\\Users" print(users_folder) new_line = "\\n" print(len(new_line))
Второй способ опирается на использование так называемых сырых (raw) строк: если перед началом литерала строки поставить символ “r”, то символ обратного слеша теряет свою особую роль внутри неё.
users_folder = r"C:\Users" print(users_folder) new_line = r"\n" print(len(new_line))
Сам факт того, что при ручном прописывании пути в виде строки приходится проявлять дополнительную бдительность намекает на то, что должен быть более осмысленный способ составлении пути.
/
Соединение элементов пути#
Рассмотрим конкретный пример. Пусть у нас имеется строка folder, представляющая путь к каталогу, и строка filename, представляющее имя некоего файла внутри этого каталога.
folder = "directory" filename = "file.txt"
Чтобы открыть этот файл, нам потребуется соединить эти две строки, учитывая разделитель каталогов.
Конечно, можно вспомнить, что путь — строка, а значит их можно конкатенировать. Но, что если кто-то захочет запустить ваш код на машине с другой операционной системой? Гораздо целесообразнее воспользоваться для этих целей специальными средствами. Самый надежный способ — метод os.path.join, который на вход принимает произвольное количество имен файлов и соединяет их тем символом, который используется в качестве разделителя на той конкретной машине, на которой скрипт запущен сейчас.
import os path = os.path.join(folder, filename) print(path)
Альтернативой является модуль pathlib, который позволяет обращаться с путями файловой системы в объектно ориентированном стиле, т.е. путь больше не представляется в виде строки, а в виде специального объекта, который в любой момент может быть приведен к строке конструктором строки str.
Для создания такого объекта обычно используют класс Path, при создании экземпляра которого учитывается операционная система, на которой запущен данный скрипт.
from pathlib import Path folder = Path(folder) print(f"{folder=}, {str(folder)=}")
folder=WindowsPath('directory'), str(folder)='directory'
В ячейке выше создается объект типа Path из строки folder и вывод сообщает, что создался объект WindowsPath('directory. Обратите внимание, что автоматически создался путь OS Windows, т.к. этот скрипт запускался под управлением этой операционной системы.
Чтобы присоединить имя файла к объекту folder, можно использовать оператор “/” вне зависимости от операционной системы.
path = folder / filename print(f"{path=}, {str(path)=}")
path=WindowsPath('directory/file.txt'), str(path)='directory\\file.txt'
Обратите внимание на то, что при приведении к строке автоматически получилась строка с разделителем в стиле OS Windows, т.к. при генерации материалов использовался компьютер под управлением OS Windows.
Автор курса рекомендует всегда использовать средства модулей os.path или pathlib, даже если вам известно, что ваш скрипт будет запускаться под управлением какой-то конкретной операционной системы, чтобы писать более надежный код и формировать полезные привычки.
Извлечение элементов из пути#
Иногда может стоять обратная задача: дан путь, а из него надо что-то извлечь.
path = r"C:\Users\fadeev\folder\file.txt"
Метод os.path.splitdrive разбивает строку на логический раздел и остальное (актуально в основном на OS Windows).
print(f"{path=}") drive, tail = os.path.splitdrive(path) print(f"{drive=}, {tail=}")
path='C:\\Users\\fadeev\\folder\\file.txt' drive='C:', tail='\\Users\\fadeev\\folder\\file.txt'
Метод os.path.dirname выделяет из пути родительский каталог.
parent_folder = os.path.dirname(path) print(f"{parent_folder=}")
parent_folder='C:\\Users\\fadeev\\folder'
Метод os.path.basename наоборот извлекает имя файла или папки, на которую данный путь указывает без учета родительского каталога.
filename = os.path.basename(path) print(f"{filename=}")
Метаинформация файла/каталога#
Имея путь, можно запрашивать у операционной системы информацию о том, что находится по этому пути. Важно понимать, что на этом этапе всегда происходит запрос к операционной системе и, если у запустившего программу пользователя не хватает привилегий для выполнения запрошенной операции, то в зависимости от операционной системы вы можете получить разные ответы.
Самый фундаментальный вопрос, который можно задать — существует ли вообще что-нибудь по указанному пути? Метод os.path.exists отвечает как раз на этот вопрос.
print(f"{os.path.exists(path)=}, {os.path.exists('filesystem.ipynb')=}")
os.path.exists(path)=False, os.path.exists('filesystem.ipynb')=True
Методы os.path.isdir и os.path.isfile позволяют определить располагает ли по этому пути каталог или файл соответственно. Оба метода возвращают False, если по переданному пути ничего не располагается.
print(f"{os.path.isdir(folder)=}, {os.path.isfile('filesystem.ipynb')=}")
os.path.isdir(folder)=True, os.path.isfile('filesystem.ipynb')=True
Также иногда бывает полезно узнать время создания (последнего изменения) или последнего доступа к файлу или каталогу. Для этих целей существуют методы os.path.getatime, os.path.getmtime и os.path.getctime. Размер файла можно узнать методом os.path.getsize.
Содержимое каталога#
В ряде задач может потребоваться узнать содержимое определенного каталога, например, чтобы потом в цикле обработать каждый элемент каталога. В самых простых случаях достаточно метода os.listdir, который возвращает список файлов/каталогов в указанной директории. По умолчанию — текущая директория.
for filename in os.listdir(): print(filename, end=" ")
.ipynb_checkpoints about_12_and_so_on.ipynb about_python.ipynb argparse.ipynb custom_classes.ipynb custom_exceptions.ipynb decorators.ipynb dictionaries.ipynb dynamic_typing.ipynb exceptions.ipynb exercises1.ipynb exercises2.ipynb exercises3.ipynb files.ipynb filesystem.ipynb functions.ipynb garbage_collector.ipynb generators.ipynb if_for_range.ipynb inheritance.ipynb iterators.ipynb json.ipynb jupyter.ipynb LBYL_vs_EAFP.ipynb list_comprehensions.ipynb mutability.ipynb numbers_and_lists.ipynb operators_overloading.ipynb polymorphism.ipynb python_scripts.ipynb scripts_vs_modules.ipynb sequencies.ipynb tmp
Важно помнить, что согласно документации этот метод возвращает список файлов в произвольном порядке, т.е. он ни коим образом не отсортирован. Если требуется отсортировать их по названию, например, в алфавитном порядке, то можно воспользоваться встроенной функцией sorted. Практически во всех остальных случаях лучше выбрать os.scandir, которая не только возвращает содержимое каталога (тоже в произвольном порядке), но и метаинформацию о каждом файле.
Метод glob.glob модуля стандартной библиотеки glob позволяет фильтровать содержимое каталога на основе шаблона. В ячейке ниже демонстрируется, как можно найти все файлы в каталоге, которые начинаются с символа “a”, а завершаются расширением “.ipynb”.
import glob for filename in glob.glob("a*.ipynb"): print(filename)
about_12_and_so_on.ipynb about_python.ipynb argparse.ipynb
Создание, копирование, перемещение и удаление файлов и каталогов#
Метод os.mkdir создаёт каталог, но две особенности:
-
если такой каталог уже существует, то бросается исключение;
-
если родительского каталога не существует, то тоже бросается исключение.
Альтернативой является метод os.makedirs имеет опциональный параметр exist_ok, который позволяет игнорировать ошибку, возникающую при попытке создать уже существующий каталог. Кроме того, если для создания указанного каталога, потребуется создать несколько директорий по пути, то они тоже будут созданы.
Таким образом метод os.mkdir более осторожный, т.к. он точно даст знать, если вы пытаетесь повторно создать директорию, а также если вы где-то ошиблись в пути, а метод os.makedirs более гибкий, позволяющий сократить объем кода, но если вы ошиблись при составлении желаемого пути (например, опечатались в имени одного каталога), то вы не получите никакого сообщения об ошибке и итоговая директория все равно будет создана.
Модуль стандартной библиотеки shutil содержит набор методов, имитирующих методы командной строки, что позволяет копировать файлы (методы shutil.copy, shutil.copy2 и shutil.copyfile), копировать директории с их содержимым (метод shutil.copytree), удалять директории (метод shutil.rmtree) и перемещать файлы или директории (метод shutil.move).
Удалять файлы можно методом os.remove.
Время на прочтение10 мин
Количество просмотров53K
В каждой операционной системе существуют свои правила построения путей к файлам. Например, в Linux для путей используются прямые слэши (“/”), а в Windows — обратные слэши (“\”).
Это незначительное отличие может создать проблемы, если вы занимаетесь проектом и хотите, чтобы другие разработчики, работающие в разных операционных системах, могли дополнить ваш код.
К счастью, если вы пишете на Python, то с этой задачей успешно справляется модуль Pathlib. Он обеспечит одинаковую работу ваших путей к файлам в разных операционных системах. Кроме того, он предоставляет функциональные возможности и операции, которые помогут вам сэкономить время при обработке и манипулировании путями.
Необходимые условия
Pathlib по умолчанию поставляется с Python >= 3.4. Однако, если вы используете версию Python ниже 3.4, у вас не будет доступа к этому модулю.
Как работает Pathlib?
Чтобы разобраться, как можно построить базовый путь с помощью Pathlib, давайте создадим новый файл Python example.py и поместим его в определенный каталог.
Откройте файл и введите следующее:
import pathlib
p = pathlib.Path(__file__)
print(p)example.py
В данном примере мы импортируем модуль Pathlib. Затем создаем новую переменную p, чтобы сохранить путь. Здесь мы используем объект Path из Pathlib со встроенной в Python переменной под названием __file__. Эта переменная служит ссылкой на путь к файлу, в котором мы ее прописываем, а именно, example.py.
Если мы выведем p, то получим путь к файлу, в котором сейчас находимся:
/home/rochdikhalid/dev/src/package/example.pyВыше показано, что Pathlib создает путь к этому файлу, помещая этот конкретный скрипт в объект Path. Pathlib содержит множество объектов, таких как PosixPath() и PurePath(), о которых мы узнаем больше в следующих разделах.
Pathlib делит пути файловой системы на два разных класса, которые представляют два типа объектов пути: Pure Path и Concrete Path.
Pure path предоставляет утилиты для обработки пути к файлу и манипулирования им без совершения операций записи, в то время как Concrete path позволяет производить обработку пути к файлу и выполнять операции записи.
Другими словами, Concrete path — это подкласс Pure path. Он наследует манипуляции от родительского класса и добавляет операции ввода/вывода, которые выполняют системные вызовы.
Pure path в Python
Pure path управляет путем к файлу на вашей машине, даже если он принадлежит другой операционной системе.
Допустим, вы работаете в Linux и хотите использовать путь к файлу Windows. Здесь объекты класса Pure path помогут вам обеспечить работу пути на вашей машине с некоторыми базовыми операциями, такими как создание дочерних путей или доступ к отдельным частям пути.
Но Pure path не сможет имитировать некоторые другие операции, такие как создание каталога или файла, потому что вы не находитесь в этой операционной системе.
Как использовать Pure path
Как видно из приведенной выше диаграммы, Pure path состоит из трех классов, которые обрабатывают любой путь к файловой системе на вашем компьютере:
PurePath() — это корневой узел, который обеспечивает операции по обработке каждого объекта пути в Pathlib.
Когда вы инстанцируете PurePath(), он создает два класса для обработки путей Windows и других, отличных от Windows. PurePath() создает общий объект пути «agnostic path», независимо от операционной системы, в которой вы работаете.
In [*]: pathlib.PurePath('setup.py')
Out[*]: PurePosixPath('setup.py')PurePath() в приведенном выше примере создает PurePosixPath(), поскольку мы предположили, что работаем на машине Linux. Но если вы создадите его на Windows, то получите что-то вроде PureWindowsPath('setup.py').
PurePosixPath() — это дочерний узел PurePath(), реализованный для путей файловой системы, отличной от Windows.
In [*]: pathlib.PurePosixPath('setup.py')
Out[*]: PurePosixPath('setup.py')Если вы инстанцируете PurePosixPath() в Windows, то не возникнет никакой ошибки, просто потому что этот класс не выполняет системных вызовов.
PureWindowsPath() — это дочерний узел PurePath(), реализованный для путей файловой системы Windows.
In [*]: pathlib.PureWindowsPath('setup.py')
Out[*]: PureWindowsPath('setup.py')То же самое относится и к PureWindowsPath(), поскольку этот класс не предусматривает системных вызовов, следовательно, его инстанцирование не вызовет ошибок для других операционных систем.
Свойства Pure path
Каждый подкласс в PurePath() предоставляет следующие свойства:
PurePath().parent выводит родительский класс:
In [*]: pathlib.PurePath('/src/goo/scripts/main.py').parent
Out[*]: PurePosixPath('/src/goo/scripts')В примере выше мы используем свойство .parent, чтобы получить путь к логическому родителю main.py.
PurePath().parents[] выводит предков пути:
In [*]: p = pathlib.PurePath('/src/goo/scripts/main.py')
p.parents[0]
Out[*]: PurePosixPath('/src/goo/scripts')
In [*]: p.parents[1]
Out[*]: PurePosixPath('/src/goo')Вы всегда должны указывать индекс предка в квадратных скобках, как показано выше. В Python 3.10 и выше можно использовать срезы и отрицательные значения индекса.
PurePath().name предоставляет имя последнего компонента вашего пути:
In [*]: pathlib.PurePath('/src/goo/scripts/main.py').name
Out[*]: 'main.py'В этом примере конечным компонентом пути является main.py. Таким образом, свойство .name выводит имя файла main.py, то есть main с суффиксом .py.
В свою очередь, PurePath().suffix предоставляет расширение файла последнего компонента вашего пути:
In [*]: pathlib.PurePath('/src/goo/scripts/main.py').suffix
Out[*]: '.py'По сравнению со свойством .name, .suffix выводит расширение файла и исключает имя файла.
PurePath().stem выводит только имя конечного компонента вашего пути без суффикса:
In [*]: pathlib.PurePath('/src/goo/scripts/main.py').stem
Out[*]: 'main'Как видно выше, свойство .stem исключает суффикс конечного компонента main.py и предоставляет только имя файла.
Методы Pure path
Каждый подкласс PurePath() предоставляет следующие методы:
PurePath().is_absolute() проверяет, является ли ваш путь абсолютным или нет:
In [*]: p = pathlib.PurePath('/src/goo/scripts/main.py')
p.is_absolute()
Out[*]: True
In [*]: o = pathlib.PurePath('scripts/main.py')
o.is_absolute()
Out[*]: FalseОбратите внимание, что абсолютный путь состоит из корня и имени диска. В данном случае PurePath() не позволяет нам узнать имя диска.
Если вы используете PureWindowsPath(), то можете репрезентовать абсолютный путь, содержащий имя диска, как PureWindowsPath('c:/Program Files').
PurePath().is_relative() проверяет, принадлежит ли данный путь другому заданному пути или нет:
In [*]: p = pathlib.PurePath('/src/goo/scripts/main.py')
p.is_relative_to('/src')
Out[*]: True
In [*]: p.is_relative_to('/data')
Out[*]: FalseВ данном примере заданный путь /src является частью или принадлежит пути p, в то время как другой заданный путь /data выдает False, поскольку он не имеет никакого отношения к пути p.
PurePath().joinpath() конкатенирует путь с заданными аргументами (дочерними путями):
In [*]: p = pathlib.PurePath('/src/goo')
p.joinpath('scripts', 'main.py')
Out[*]: PurePosixPath('/src/goo/scripts/main.py')Обратите внимание, что нет необходимости добавлять слэши в заданные аргументы, так как метод .joinpath() делает это за вас.
PurePath().match() проверяет, соответствует ли путь заданному шаблону:
In [*]: pathlib.PurePath('/src/goo/scripts/main.py').match('*.py')
Out[*]: True
In [*]: pathlib.PurePath('/src/goo/scripts/main.py').match('goo/*.py')
Out[*]: True
In [*]: pathlib.PurePath('src/goo/scripts/main.py').match('/*.py')
Out[*]: FalseИсходя из приведенных примеров, шаблон должен совпадать с путем. Если заданный шаблон является абсолютным, то и путь должен быть абсолютным.
PurePath().with_name() изменяет имя конечного компонента вместе с его суффиксом:
In [*]: p = pathlib.PurePath('/src/goo/scripts/main.py')
p.with_name('app.js')
Out[*]: PurePosixPath('/src/goo/scripts/app.js')
In [*]: p
Out[*]: PurePosixPath('/src/goo/scripts/main.py')Метод .with_name() не изменяет имя последнего компонента навсегда. Кроме того, если указанный путь не содержит имени, возникает ошибка, как отмечено в официальной документации.
PurePath().with_stem() изменяет только имя последнего компонента пути:
In [*]: p = pathlib.PurePath('/src/goo/scripts/main.py')
p.with_stem('app.py')
Out[*]: PurePosixPath('/src/goo/scripts/app.py')
In [*]: p
Out[*]: PurePosixPath('/src/goo/scripts/main.py')Это аналогично методу .with_name(). Метод .with_stem() изменяет имя последнего компонента на время. Также, если указанный путь не содержит имени, произойдет ошибка.
PurePath().with_suffix() временно изменяет суффикс или расширение последнего компонента пути:
In [*]: p = pathlib.PurePath('/src/goo/scripts/main.py')
p.with_suffix('.js')
Out[*]: PurePosixPath('/src/goo/scripts/main.js')Если имя заданного пути не содержит суффикса, метод .with_suffix() добавляет суффикс за вас:
In [*]: p = pathlib.PurePath('/src/goo/scripts/main')
p.with_suffix('.py')
Out[*]: PurePosixPath('/src/goo/scripts/main.py')Но если мы не включим суффикс и оставим аргумент пустым ' ', текущий суффикс будет удален.
In [*]: p = pathlib.PurePath('/src/goo/scripts/main')
p.with_suffix('')
Out[*]: PurePosixPath('/src/goo/scripts/main')Некоторые методы, такие как .with_stem() и .is_relative_to(), были недавно добавлены в Python 3.9 и выше. Поэтому, если вы их вызываете, используя Python 3.8 или ниже, будет выдана ошибка атрибута.
Concrete Path в Python
Concrete Paths позволяет обрабатывать, манипулировать и выполнять операции записи над различными путями файловой системы.
Другими словами, этот тип объекта пути помогает нам создать, скажем, новый файл, новый каталог и выполнить другие операции ввода/вывода, не находясь в данной операционной системе.
Как использовать Concrete path
В Concrete path обрабатываются любые пути файловой системы и выполняются системные вызовы на вашем компьютере. Эти объекты пути являются дочерними путями Pure path и состоят из трех подклассов, как и сами Pure path:
Path() — это дочерний узел PurePath(), он обеспечивает операции обработки с возможностью выполнения процесса записи.
Когда вы инстанцируете Path(), он создает два класса для работы с путями Windows и отличных от Windows. Как и PurePath(), Path() также создает общий объект пути «agnostic path», независимо от операционной системы, в которой вы работаете.
In [*]: pathlib.Path('setup.py')
Out[*]: PosixPath('setup.py')Path() в приведенном выше примере создает PosixPath(), поскольку мы предполагаем, что работаем на Linux. Но если вы создадите его в Windows, то получите что-то вроде WindowsPath('setup.py').
PosixPath() — это дочерний узел Path() и PurePosixPath(), реализованный для обработки и управления путями файловой системы, отличной от Windows.
In [*]: pathlib.PosixPath('setup.py')
Out[*]: PosixPath('setup.py')Вы получите ошибку при инстанцировании PosixPath() на компьютере с Windows, поскольку нельзя выполнять системные вызовы во время работы в другой операционной системе.
WindowsPath() — это дочерний узел Path() и PureWindowsPath(), реализованный для путей файловой системы Windows.
In [*]: pathlib.WindowsPath('setup.py')
Out[*]: WindowsPath('setup.py')То же самое относится и к WindowsPath(), поскольку вы работаете в другой операционной системе — поэтому ее инстанцирование приведет к ошибке.
Свойства Concrete path
Поскольку Concrete path является подклассом Pure path, вы можете делать с Concrete path все, что угодно, используя свойства PurePath(). Это означает, что мы можем использовать, например, свойство .with_suffix для добавления суффикса к Concrete path:
In [*]: p = pathlib.Path('/src/goo/scripts/main')
p.with_suffix('.py')
Out[*]: PosixPath('/src/goo/scripts/main.py')Или вы можете проверить, относится ли данный путь к исходному пути с помощью .is_relative_to:
In [*]: p = pathlib.Path('/src/goo/scripts/main.py')
p.is_relative_to('/src')
Out[*]: TrueВсегда помните, что Concrete path наследуют операции обработки от Pure path и добавляют операции записи, которые выполняют системные вызовы и конфигурации ввода/вывода.
Методы Concrete path
Каждый подкласс Path() предоставляет следующие методы для обработки путей и выполнения системных вызовов:
Path().iterdir() возвращает содержимое каталога. Допустим, у нас есть следующая папка, содержащая следующие файлы:
data
population.json
density.json
temperature.yml
stats.md
details.txtпапка данных
Чтобы вернуть содержимое каталога /data, вы можете использовать метод .iterdir():
In [*]: p = pathlib.Path('/data')
for child in p.iterdir():
print(child)
Out[*]: PosixPath('/data/population.json')
PosixPath('/data/density.json')
PosixPath('/data/temprature.yml')
PosixPath('/data/stats.md')
PosixPath('/data/details.txt')Метод .itertir() создает итератор, который случайным образом перечисляет файлы.
Path().exists() проверяет, существует ли файл/каталог в текущем пути. Давайте воспользуемся каталогом из предыдущего примера (наш текущий каталог — /data):
In [*]: p = pathlib.Path('density.json').exists()
p
Out[*]: TrueМетод .exists() возвращает True, если заданный файл существует в каталоге data. Метод возвращает False, если его нет.
In [*]: p = pathlib.Path('aliens.py').exists()
p
Out[*]: FalseТо же самое относится и к каталогам, метод возвращает True, если заданный каталог существует, и False, если каталог отсутствует.
Path().mkdir() создает новый каталог по заданному пути:
In [*]: p = pathlib.Path('data')
directory = pathlib.Path('data/secrets')
directory.exists()
Out[*]: False
In [*]: directory.mkdir(parents = False, exist_ok = False)
directory.exists()
Out[*]: TrueСогласно официальной документации, метод .mkdir() принимает три аргумента. В данный момент мы сосредоточимся только на аргументах parents и exist_ok.
По умолчанию оба аргумента имеют значение False. Аргумент parents выдает ошибку FileNotFound в случае отсутствия родителя, а exist_ok выдает ошибку FileExists, если данный каталог уже существует.
В приведенном примере вы можете установить аргументы в True, чтобы игнорировать упомянутые ошибки и обновить каталог.
Мы также можем создать новый файл по указанному пути с помощью метода Path().touch():
In [*]: file = pathlib.Path('data/secrets/secret_one.md')
file.exists()
Out[*]: False
In [*]: file.touch(exist_ok = False)
file.exists()
Out[*]: TrueТа же логика применима к методу .touch(). Здесь параметр exist_ok может быть установлен в True, чтобы игнорировать ошибку FileExists и обновить файл.
Path().rename() переименовывает файл/каталог по заданному пути. Рассмотрим пример на примере нашего каталога /data:
In [*]: p = pathlib.Path('density.json')
n = pathlib.Path('density_2100.json')
p.rename(n)
Out[*]: PosixPath('density_2100.json')Если вы присваиваете методу несуществующий файл, он выдает ошибку FileNotFound. То же самое относится и к каталогам.
Path().read_text() возвращает содержимое файла в формате строки:
In [*]: p = pathlib.Path('info.txt')
p.read_text()
Out[*]: 'some text added'Также вы можете использовать метод write_text() для записи содержимого в файл:
In [*]: p = pathlib.Path('file.txt')
p.write_text('we are building an empire')
Out[*]: 'we are building an empire'Обратите внимание, что метод .write_text() был добавлен в Python 3.5 и недавно был обновлен в Python 3.10, получив некоторые дополнительные параметры.
Важное замечание
Вы можете спросить себя, зачем использовать пути файловой системы Windows — ведь каждый пакет должен быть совместим и с другими операционными системами, а не только с Windows.
Вы правы, если цель состоит в том, чтобы сделать путь, не зависящий от ОС. Но иногда мы не можем этого сделать из-за некоторых параметров, уникальных для Windows или Posix систем. Вот почему предоставляются данные объекты — чтобы помочь разработчикам справиться с такими вариантами использования.
Некоторые пакеты нацелены на решение проблем, присутствующих только в экосистеме Windows, и Python поддерживает эти юзкейсы в данной библиотеке.
Что дальше?
Надеемся, это руководство помогло вам узнать, как и зачем использовать Pathlib и в чем его польза для обработки и манипулирования путями файловой системы.
Было бы здорово обыграть полученные знания и воплотить их в реальном проекте.
В этой статье я рассказал об основах, необходимых для использования Pathlib в вашем проекте.
В официальной документации описано больше методов и свойств, которые вы можете применить к путям файловой системы: Pathlib — Объектно-ориентированные пути файловой системы
Всех желающих приглашаем на открытое занятие, на котором научимся работать со встроенными модулями. Узнаем про модули (os, pathlib, functools). Регистрация открыта по ссылке.
Для работы с файловой системой в Python используют модули
os, os.path и shututil, а для операций с файлами – встроенные функции open(), close(), read(), readline(), write() и т. д. Прежде, чем мы перейдем
к примерам использования конкретных методов, отметим один важный момент – корректный формат пути к файлам и каталогам.
Дело в том, что Python считает некорректным стандартный
для Windows формат: если указать путь к файлу в привычном виде 'C:\Users\User\Python\letters.py', интерпретатор вернет ошибку. Лучше
всего указывать путь с помощью r-строк
или с экранированием слэшей:
r'C:\Users\User\Python\letters.py'
'C:\\Users\\User\\Python\\letters.py'
Иногда также путь указывают с обратными слэшами:
'C:/Users/User/Python/letters.py'
🐍🎓 Библиотека собеса по Python
🐍🧩 Библиотека задач по Python
Получение информации о файлах и директориях
Метод getcwd() возвращает
путь к текущей рабочей директории в виде строки:
>>> import os
>>> os.getcwd()
'C:\\Users\\User\\Python'
С помощью метода os.listdir() можно получить список всех поддиректорий и файлов текущего рабочего каталога, при этом содержимое вложенных папок не отображается:
>>> os.listdir()
['Data', 'lambda_functions.py', 'letters.py', 'os_methods.py', 'passw_generator.py', 'points.py', 'population.py']
Метод os.walk() возвращает генератор, в котором содержится
вся информация о рабочем каталоге, включая содержимое всех поддиректорий:
>>> import os
>>> my_cwd = os.getcwd()
>>> result = os.walk(my_cwd)
>>> for i, j, k in result:
for file in k:
print(file)
lambda_functions.py
letters.py
os_methods.py
passw_generator.py
points.py
population.py
books_to_process.txt
challenge_data.txt
ledger.txt
Много полезных методов содержится в модуле os.path. Так можно извлечь имя файла из полного пути:
>>> os.path.basename(r'C:\Users\User\Python\letters.py')
'letters.py'
А так можно получить путь к директории / файлу, в который не
включается собственно поддиректория или имя файла:
>>> os.path.dirname(r'C:\Users\User\Python\Data')
'C:\\Users\\User\\Python'
Метод path.isabs() покажет, является ли
путь абсолютным или относительным:
>>> os.path.isabs(r'C:\Users\User\Python\Data')
True
>>> os.path.isabs(r'.\Python\Data')
False
>>>
Метод path.isdir() возвращает True, если переданная в метод директория существует, и False – в противном случае:
>>> os.path.isdir(r'C:\Users\User\Python\Data\Samples')
False
Для установления факта существования файла служит path.isfile():
>>> os.path.isfile(r'C:\Users\User\Python\matrix_challenge.py')
False
Для преобразования пути в нижний регистр и нормализации слэшей используют path.normcase():
>>> os.path.normcase('C:/Users/User/Python')
'c:\\users\\user\\python'
Хотя путь к файлу (директории) представляет собой строку,
создавать полный путь с помощью конкатенации считается моветоном – нужно
использовать метод os.path.join():
# Неправильно:
my_cwd = os.getcwd()
file_name = 'my_solution.py'
path = my_cwd + '\\' + file_name
# Правильно:
path = os.path.join(my_cwd, file_name)
Результат:
C:\Users\User\Python\my_solution.py
Операции с каталогами и файлами в Python
Для создания новых директорий служит os.mkdir(); в метод нужно передать полный путь, включающий название
нового каталога:
import os
my_cwd = os.getcwd()
new_dir = 'Solutions'
path = os.path.join(my_cwd, new_dir)
os.mkdir(path)
print(os.listdir())
Результат:
['Data', 'lambda_functions.py', 'letters.py', 'os_methods.py', 'passw_generator.py', 'points.py', 'population.py', 'Solutions']
Изменить рабочую директорию можно с помощью метода os.chdir(), это аналог CLI команды cd:
>>> import os
>>> os.getcwd()
'C:\\Users\\User\\Python'
>>> os.chdir(r'C:\Users\User\Python\Data')
>>> os.getcwd()
'C:\\Users\\User\\Python\\Data'
Использование os.chdir()
может привести к ошибке, если путь к переданной в метод директории указан
неправильно или не существует. Поэтому этот метод стоит использовать только с
обработкой ошибок:
import sys, os
my_cwd = os.getcwd()
new_cwd = r'C:\Users\User\Python\MyData'
try:
os.chdir(new_cwd)
print(f'Изменяем рабочую директорию на {os.getcwd()}')
except:
print(f'Произошла ошибка {sys.exc_info()}')
finally:
print('Восстанавливаем рабочую директорию на прежнюю')
os.chdir(my_cwd)
print(f'Текущая рабочая директория - {os.getcwd()}')
Вывод:
Произошла ошибка (<class 'FileNotFoundError'>, FileNotFoundError(2, 'Не удается найти указанный файл'), <traceback object at 0x024E9828>)
Восстанавливаем рабочую директорию на прежнюю
Текущая рабочая директория - C:\Users\User\Python
Python для новичков: бессрочный доступ к знаниям и поддержка экспертов
Онлайн-курс «Основы программирования на Python» от Proglib academy предлагает 32 практических урока с персональной обратной связью от экспертов, где вы создадите 4 реальных проекта для портфолио и получите все необходимые навыки для старта карьеры в IT.
Создание директорий в Python
Для создания новых каталогов используют два метода:
- os.mkdir() – аналог CLI команды
mkdir; создает новую папку по указанному пути, при условии, что все указанные промежуточные (вложенные) директории уже существуют. - os.makedirs() – аналог CLI команды
mkdir -p dir1\dir2; помимо создания целевой папки, создает все промежуточные директории, если они не существуют.
Пример использования os.mkdir():
import os
new_dir = 'NewProjects'
parent_dir = r 'C:\Users\User\Python'
path = os.path.join(parent_dir, new_dir)
os.mkdir(path)
print(f'Директория {new_dir} создана: {os.listdir()}')
Результат:
Директория NewProjects создана: ['Data', 'lambda_functions.py', 'letters.py', 'NewProjects', 'os_methods.py', 'Other', 'passw_generator.py', 'points.py', 'population.py', 'Solutions']
Пример использования makedirs():
import os
new_dir = 'Django'
parent_dir = r'C:\Users\User\Python\Other\Projects\Modules'
path = os.path.join(parent_dir, new_dir)
os.makedirs(path)
print(f'Директория {new_dir} создана по адресу {os.path.dirname(path)}')
Результат:
Директория Django создана по адресу C:\Users\User\Python\Other\Projects\Modules
Копирование файлов и директорий в Python
Для копирования файлов используют метод shutil.copy2(), который принимает два аргумента
– источник файла и директорию, в которую нужно скопировать файл:
import os
import shutil
dest_path = r'C:\Users\User\Python\Data'
source_path = r'C:\Users\User\lambda_exp.txt'
print(f'Файлы в директории {os.path.basename(dest_path)} до копирования файла \
{os.path.basename(source_path)}: {os.listdir(dest_path)}\n')
copy_file = shutil.copy2(source_path, dest_path)
print(f'Файлы в директории {os.path.basename(dest_path)} после копирования файла \
{os.path.basename(source_path)}: {os.listdir(dest_path)}')
Вывод:
Файлы в директории Data до копирования файла lambda_exp.txt: ['books_to_process.txt', 'challenge_data.txt', 'ledger.txt']
Файлы в директории Data после копирования файла lambda_exp.txt: ['books_to_process.txt', 'challenge_data.txt', 'lambda_exp.txt', 'ledger.txt']
Помимо метода shutil.copy2(),
для копирования файлов можно пользоваться методом shutil.copy(). Разница между
этими двумя методами в том, что в отличие от shutil.copy2(),
метод shutil.copy() копирует только
содержимое файла, но не метаданные:
import os
import shutil
dest_path = r'C:\Users\User\Python\Data'
source_path = r'C:\Users\User\logfile.txt'
print(f'Файлы в директории {os.path.basename(dest_path)} до копирования файла \
{os.path.basename(source_path)}: {os.listdir(dest_path)}\n')
print(f'Метаданные: {os.stat(source_path)}\n')
copy_file = shutil.copy(source_path, dest_path)
print(f'Файлы в директории {os.path.basename(dest_path)} после копирования файла \
{os.path.basename(source_path)}: {os.listdir(dest_path)}\n')
print(f'Метаданные: {os.stat(dest_path)}\n')
Вывод:
Файлы в директории Data до копирования файла logfile.txt: ['books_to_process.txt', 'challenge_data.txt', 'lambda_exp.txt']
Метаданные: os.stat_result(st_mode=33206, st_ino=18014398509552989, st_dev=4236505663, st_nlink=1, st_uid=0, st_gid=0, st_size=455, st_atime=1629682315, st_mtime=1629681887, st_ctime=1629682315)
Файлы в директории Data после копирования файла logfile.txt: ['books_to_process.txt', 'challenge_data.txt', 'lambda_exp.txt', 'logfile.txt']
Метаданные: os.stat_result(st_mode=16895, st_ino=11821949021901021, st_dev=4236505663, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1675257729, st_mtime=1675257729, st_ctime=1675084801)
Все содержимое каталога сразу можно скопировать с помощью shutil.copytree():
import os
import shutil
dest_path = r'C:\Users\User\Python\Other\Files'
source_path = r'C:\Users\User\Python\Other\Scripts'
print(f'Содержимое директории {os.path.basename(dest_path)} до копирования каталога \
{os.path.basename(source_path)}: {os.listdir(dest_path)}\n')
copy_dir = shutil.copytree(source_path, dest_path, dirs_exist_ok=True)
print(f'Содержимое директории {os.path.basename(dest_path)} после копирования \
{os.path.basename(source_path)}: {os.listdir(dest_path)}\n')
Вывод:
Содержимое директории Files до копирования каталога Scripts: []
Содержимое директории Files после копирования Scripts: ['progression.py', 'sitemap_generator.py']
Перемещение файлов и директорий
Для перемещения файлов используют метод shutil.move():
import os
import shutil
dest_path = r'C:\Users\User\Python\Other\Scripts'
source_path = r'C:\Users\User\Desktop\sitemap_generator.py'
print(f'Содержимое директории {os.path.basename(dest_path)} до копирования каталога \
{os.path.basename(source_path)}: {os.listdir(dest_path)}\n')
copy_dir = shutil.move(source_path, dest_path)
print(f'Содержимое директории {os.path.basename(dest_path)} после копирования \
{os.path.basename(source_path)}: {os.listdir(dest_path)}\n')
Вывод:
Содержимое директории Scripts до копирования каталога sitemap_generator.py: ['progression.py', 'wiki_scraping.py']
Содержимое директории Scripts после копирования sitemap_generator.py: ['progression.py', 'sitemap_generator.py', 'wiki_scraping.py']
Для перемещения содержимого всей директории в качестве
функции указывают shutil.copytree():
copy_dir = shutil.move(source_path, dest_path, copy_function = shutil.copytree)
Удаление файлов и директорий
Для удаления директории вместе со всеми файлами используют shutil.rmtree():
import os
import shutil
dir_path = r'C:\Users\User\Python\Other'
remove_dir = 'Files'
path = os.path.join(dir_path, remove_dir)
print(f'Содержимое директории {os.path.basename(dir_path)} до удаления каталога \
{remove_dir}: {os.listdir(dir_path)}\n')
shutil.rmtree(path)
print(f'Содержимое директории {os.path.basename(dir_path)} после удаления \
{remove_dir}: {os.listdir(dir_path)}\n')
Вывод:
Содержимое директории Other до удаления каталога Files: ['Files', 'Projects']
Содержимое директории Other после удаления Files: ['Projects']
Другой метод для удаления пустых директорий – os.rmdir():
import os
import shutil
dir_path = r'C:\Users\User\Python\Other'
remove_dir = 'Scripts'
path = os.path.join(dir_path, remove_dir)
print(f'Содержимое директории {os.path.basename(dir_path)} до удаления каталога \
{remove_dir}: {os.listdir(dir_path)}\n')
os.rmdir(path)
print(f'Содержимое директории {os.path.basename(dir_path)} после удаления \
{remove_dir}: {os.listdir(dir_path)}\n')
Вывод:
Содержимое директории Other до удаления каталога Scripts: ['Projects', 'Scripts']
Содержимое директории Other после удаления Scripts: ['Projects']
Очевидный минус метода os.rmdir()
в том, что он работает только на пустых директориях – если поместить в каталог Scripts хотя бы один файл,
удалить его с os.rmdir() уже не получится:
Traceback (most recent call last):
File "C:\Users\User\Python\os_methods.py", line 8, in <module>
os.rmdir(path)
OSError: [WinError 145] Папка не пуста: 'C:\\Users\\User\\Python\\Other\\Scripts'
Для удаления файлов используют метод os.remove():
import os
import shutil
dir_path = r'C:\Users\User\Python\Other\Scripts'
remove_file = 'tetris_game.py'
path = os.path.join(dir_path, remove_file)
print(f'Содержимое директории {os.path.basename(dir_path)} до удаления файла \
{remove_file}: {os.listdir(dir_path)}\n')
os.remove(path)
print(f'Содержимое директории {os.path.basename(dir_path)} после удаления \
{remove_file}: {os.listdir(dir_path)}\n')
Вывод:
Содержимое директории Scripts до удаления файла tetris_game.py: ['tetris_game.py']
Содержимое директории Scripts после удаления tetris_game.py: []
Работа с файлами в Python
Открыть файл для проведения каких-либо манипуляций можно
двумя способами:
- С помощью функции open() – в этом случае после завершения работы нужно будет закрыть файл с помощью close():
f = open('task.txt', 'a', encoding='utf-8')
f.write('\n2) Написать модуль авторизации')
f.close()
- С использованием менеджера контекста with, который автоматически и самостоятельно закроет файл, когда надобность в нем отпадет:
with open('task.txt', 'a', encoding='utf-8') as f:
f.write('\n2) Написать модуль авторизации')
Типы файлов
В Python все файлы делятся на:
- Текстовые
't' - Бинарные (двоичные)
'b'
Если никакой определенный тип файла не указан, по умолчанию Python считает, что пользователь работает с текстовыми файлами. Поэтому для работы с изображениями, мультимедийными файлами и pdf, например, следует указывать, что тип файла относится к 'b'.
Режимы доступа и записи
| ‘r’ | Открывает файл для чтения. Возвращает ошибку, если указанный файл не существует. |
| ‘w’ | Открывает файл для записи, причем перезаписывает содержимое, если оно есть. Создает файл, если он не существует. |
| ‘a’ | Открывает файл для записи и добавляет новую информацию, не перезаписывая существующую. Создает файл, если он не существует. |
| ‘w+’ | Открывает файл для чтения и записи, перезаписывает содержимое. |
| ‘r+’ | Открывает файл для чтения и дополнения, не перезаписывает содержимое. |
| ‘x’ | Создает новый пустой файл. Возвращает ошибку, если файл с таким именем уже существует. |
Примечание: для операций с двоичными файлами к указанным
параметрам нужно добавлять b,
то есть вместо 'r'
должно быть 'rb', а
вместо 'w+' – 'wb+'.
Методы работы с файлами
Для чтения данных используют read(). Метод read() по умолчанию возвращает все содержимое файла:
with open('books.txt', 'r', encoding='utf-8') as f:
info = f.read()
print(info)
Вывод:
1. "Террор", Дэн Симмонс
2. "Она же Грейс", Маргарет Этвуд
3. "Облачный атлас", Дэвид Митчелл
4. "Искупление", Иэн Макьюэн
5. "Госпожа Бовари", Гюстав Флобер
При необходимости объем выводимой информации можно ограничить
определенным количеством символов:
with open('movies.txt', 'r', encoding='utf-8') as f:
info = f.read(15)
print(info)
Вывод:
1. "Из машины"
Метод readline()
позволяет считывать информацию из текстовых файлов построчно:
with open('books.txt', 'r', encoding='utf-8') as f:
info = f.readline()
print(info)
Вывод:
1. "Террор", Дэн Симмонс
Для получения всех строк файла используют метод readlines(),
который возвращает содержимое в виде списка – вместе со всеми спецсимволами:
with open('books.txt', 'r', encoding='utf-8') as f:
info = f.readlines()
print(info)
Вывод:
['1. "Террор", Дэн Симмонс\n', '2. "Она же Грейс", Маргарет Этвуд\n', '3. "Облачный атлас", Дэвид Митчелл\n', '4. "Искупление", Иэн Макьюэн\n', '5. "Госпожа Бовари", Гюстав Флобер']
Чтобы избавиться от лишних пробелов, символа новой строки (и любых других
спецсимволов), используют методы rstrip(), lstrip()
или strip():
with open('books.txt', 'r', encoding='utf-8-sig') as f:
info = [line.strip() for line in f.readlines()]
print(info)
Вывод:
['1. "Террор", Дэн Симмонс', '2. "Она же Грейс", Маргарет Этвуд', '3. "Облачный атлас", Дэвид Митчелл', '4. "Искупление", Иэн Макьюэн', '5. "Госпожа Бовари", Гюстав Флобер']
Для записи информации в файл используют метод write():
with open('books.txt', 'a', encoding='utf-8') as f:
f.write('\n6. "Война и мир", Лев Толстой\n')
Или writelines():
with open('books.txt', 'a', encoding='utf-8') as f:
f.writelines(['7. "Преступление и наказание", Федор Достоевский\n',
'8. "Мизери", Стивен Кинг\n',
'9. "Джейн Эйр", Шарлотта Бронте\n'])
Кроме того, записывать данные в файл можно с помощью print():
with open('crm_log.txt', 'a', encoding='utf-8') as file:
print('\nСергей Леонов, 11:18, 12:23', file=file)
Чтобы узнать текущую позицию курсора в файле, используют метод tell():
with open('books.txt', 'r', encoding='utf-8-sig') as f:
f.readline()
f.read(5)
print(f.tell())
Вывод:
51
Для считывания данных из определенной позиции используют seek():
with open('movies.txt', 'r', encoding='utf-8') as f:
f.seek(53)
print(f.read())
Вывод:
3. "Дракула Брэма Стокера"
Практика
Задание 1
Имеется файл books.txt, содержащий следующую
информацию:
1. "Террор", Дэн Симмонс
2. "Она же Грейс", Маргарет Этвуд
3. "Облачный атлас", Дэвид Митчелл
4. "Искупление", Иэн Макьюэн
5. "Госпожа Бовари", Гюстав Флобер
6. "Война и мир", Лев Толстой
7. "Преступление и наказание", Федор Достоевский
8. "Мизери", Стивен Кинг
9. "Джейн Эйр", Шарлотта Бронте
Напишите программу, которая выводит первые 3 строки файла.
Решение:
with open('books.txt', 'r', encoding='utf-8') as file:
for i in range(3):
line = file.readline().strip()
print(line)
Задание 2
Напишите программу, которая получает от пользователя имя
файла и возвращает следующие данные о его содержимом:
- количество строк;
- количество слов;
- число символов без пробелов и точек.
Пример ввода:
series.txt
Содержимое файла:
1. Последнее королевство 2015
2. Рим 2005
3. Версаль 2015
4. Тюдоры 2007
5. Террор 2018
6. Человек в высоком замке 2015
7. Белая королева 2013
8. Братья по оружию 2001
9. Медичи 2016
10. Спартак 2010
Вывод:
Количество строк в файле series.txt: 10
Количество слов: 17
Число символов: 153
Решение:
filename = input()
lines, words, symbols = 0, 0, 0
with open(filename, 'r', encoding='utf-8') as file:
for i in file:
lines += 1
words += len([w for w in i.split() if w.isalpha()])
symbols += len([s for s in i if s.isalnum()])
print(f'Количество строк в файле {filename}: {lines}\n'
f'Количество слов: {words}\n'
f'Число символов: {symbols}\n'
)
Задание 3
Напишите программу, которая находит самое длинное слово в
списке книг из первого задания.
Ожидаемый результат:
Преступление
Решение:
with open('books.txt', 'r', encoding='utf-8') as file:
words = file.read().replace('"', '').split()
result = [w for w in words if len(w) == len(max(words, key=len))]
print(*result)
Задание 4
Имеется файл fruit.txt со
следующим содержимым:
Апельсин маракуйя папайя айва Яблоко
апельсин яблоко ананас банан персик Слива
Банан груша слива виноград авокадо Цитрон
Слива Груша яблоко мандарин цитрон
лимон Лайм апельсин ананас персик айва
Хурма киви хурма манго авокадо лайм
Нектарин Инжир гранат Папайя Гранат
Напишите программу, которая подсчитывает, сколько раз
название каждого фрукта встречается в тексте.
Вывод:
Названия этих фруктов встречаются в тексте:
"апельсин" - 3 раз(а)
"маракуйя" - 1 раз(а)
"папайя" - 2 раз(а)
"айва" - 2 раз(а)
"яблоко" - 3 раз(а)
"ананас" - 2 раз(а)
"банан" - 2 раз(а)
"персик" - 2 раз(а)
"слива" - 3 раз(а)
"груша" - 2 раз(а)
"виноград" - 1 раз(а)
"авокадо" - 2 раз(а)
"цитрон" - 2 раз(а)
"мандарин" - 1 раз(а)
"лимон" - 1 раз(а)
"лайм" - 2 раз(а)
"хурма" - 2 раз(а)
"киви" - 1 раз(а)
"манго" - 1 раз(а)
"нектарин" - 1 раз(а)
"инжир" - 1 раз(а)
"гранат" - 2 раз(а)
Решение:
with open('fruit.txt', 'r', encoding='utf-8') as file:
result = {}
for line in file:
words = line.strip().lower().split()
for w in words:
result[w] = result.get(w, 0) + 1
print(f'Названия этих фруктов встречаются в тексте:')
for k, v in result.items():
print(f'"{k}" - {v} раз(а)'
Задание 5
Имеются два файла, first.txt и second.txt. В первом файле
перечислены имена, во втором – должности:
Содержимое файла first.txt
Сергей Ковалев
Ирина Егорова
Никита Степанов
Марина Арефьева
Кирилл Евстегнеев
Елена Моисеева
Файл second.txt
мидл разработчик
девопс
тимлид
сеньор разработчик
продакт-менеджер
дизайнер
Напишите программу, которая открывает оба файла и выводит
сведения о сотрудниках в следующем формате:
Сотрудник Сергей Ковалев, должность - мидл разработчик
Сотрудник Ирина Егорова, должность - девопс
Сотрудник Никита Степанов, должность - тимлид
Сотрудник Марина Арефьева, должность - сеньор разработчик
Сотрудник Кирилл Евстегнеев, должность - продакт-менеджер
Сотрудник Елена Моисеева, должность – дизайнер
Решение:
with open('first.txt', 'r', encoding='utf-8') as file1, \
open('second.txt', 'r', encoding='utf-8') as file2:
for line_x, line_y in zip(file1, file2):
print(f'Сотрудник {line_x.strip()}, должность - {line_y.strip()}')
Задание 6
Напишите программу, которая:
- генерирует коды букв русского алфавита от а до я;
- вставляет в полученный список код ё;
- записывает полный алфавит (строчный и прописной варианты каждой буквы) в столбик в файл alphabet.txt.
Содержимое файла после выполнения программы:
Аа
Бб
Вв
Гг
Дд
Ее
Ёё
Жж
Зз
Ии
Йй
Кк
Лл
Мм
Нн
Оо
Пп
Рр
Сс
Тт
Уу
Фф
Хх
Цц
Чч
Шш
Щщ
Ъъ
Ыы
Ьь
Ээ
Юю
Яя
Решение:
alpha = [i for i in range(ord('а'), ord('я') + 1)]
alpha.insert(6, 1105)
with open('alphabet.txt', 'w', encoding='utf-8') as file:
for i in alpha:
file.write(chr(i).upper() + chr(i) + '\n')
Задание 7
Сведения о доходах и расходах компании хранятся в двух
файлах, income.txt и
outcome.txt. Напишите программу для
подсчета прибыли компании.
Пример файла income.txt:
RUB100000
RUB200000
RUB200000
RUB500000
RUB600000
RUB100000
RUB700000
Пример файла outcome.txt:
-RUB1000
-RUB2000
-RUB50000
-RUB200000
-RUB10000
-RUB5000
-RUB6000
-RUB10000
-RUB19000
-RUB7000
Ожидаемый результат:
Прибыль за прошлый месяц: 2090000 RUB
Решение:
income, outcome = 0, 0
with open('income.txt', 'r', encoding='utf-8') as file1, \
open('outcome.txt', 'r', encoding='utf-8') as file2:
for line in file1:
num = line.strip()[3:]
income += int(num)
for line in file2:
num = line.strip()[4:]
outcome += int(num)
print(f'Прибыль за прошлый месяц: {income - outcome} RUB')
Задание 8
Напишите программу, которая считывает сведения об
успеваемости по основным предметам из файла grades.txt,
и определяет, кто из студентов имеет средний балл >= 4.5.
Пример файла grades.txt:
Арефьева И. 5 5 4 4
Богданов С. 5 5 3 4
Гаврилов Е. 4 4 3 3
Егорова А. 3 3 3 4
Семенова Е. 4 3 3 4
Хворостов И. 5 4 5 5
Ожидаемый результат:
Арефьева И., средний балл: 4.50
Хворостов И., средний балл: 4.75
Решение:
result = {}
with open('grades.txt', 'r', encoding='utf-8') as file1:
for line in file1:
l = line.strip().split()
grades = [int(i) for i in l[-4:]]
aver_grade = sum(grades) / len(grades)
if aver_grade >= 4.5:
result[l[0] + ' ' + l[1]] = aver_grade
for student, aver_grade in result.items():
print(f'{student}, средний балл: {aver_grade:.2f}')
Задание 9
Напишите программу, которая получает от пользователя
название файла с информацией на русском языке, и выполняет транслитерацию
текста в соответствии с приведенным ниже словарем. Результат нужно записать в
файл result.txt.
Словарь:
translit = {'а': 'a', 'к': 'k', 'х': 'h', 'б': 'b', 'л': 'l', 'ц': 'c', 'в': 'v', 'м': 'm', 'ч': 'ch', 'г': 'g', 'н': 'n',
'ш': 'sh', 'д': 'd', 'о': 'o', 'щ': 'shh', 'е': 'e', 'п': 'p', 'ъ': '*', 'ё': 'jo', 'р': 'r', 'ы': 'y', 'ж': 'zh',
'с': 's', 'ь': "'", 'з': 'z', 'т': 't', 'э': 'je', 'и': 'i', 'у': 'u', 'ю': 'ju', 'й': 'j', 'ф': 'f', 'я': 'ya',
'А': 'A', 'К': 'K', 'Х': 'H', 'Б': 'B', 'Л': 'L', 'Ц': 'C', 'В': 'V', 'М': 'M', 'Ч': 'Ch', 'Г': 'G', 'Н': 'N',
'Ш': 'Sh', 'Д': 'D', 'О': 'O', 'Щ': 'Shh', 'Е': 'E', 'П': 'P', 'Ъ': '*', 'Ё': 'Jo', 'Р': 'R', 'Ы': 'Y', 'Ж': 'Zh',
'С': 'S', 'Ь': "'", 'З': 'Z', 'Т': 'T', 'Э': 'Je', 'И': 'I', 'У': 'U', 'Ю': 'Ju', 'Й': 'J', 'Ф': 'F', 'Я': 'Ya'}
Пример русского текста:
Python — это язык программирования, который широко используется в интернет-приложениях, разработке программного обеспечения, науке о данных и машинном обучении (ML). Разработчики используют Python, потому что он эффективен, прост в изучении и работает на разных платформах.
Ожидаемое содержимое result.txt:
Python — jeto yazyk programmirovaniya, kotoryj shiroko ispol'zuetsya v internet-prilozheniyah, razrabotke programmnogo obespecheniya, nauke o dannyh i mashinnom obuchenii (ML). Razrabotchiki ispol'zujut Python, potomu chto on jeffektiven, prost v izuchenii i rabotaet na raznyh platformah.
Решение:
translit = {'а': 'a', 'к': 'k', 'х': 'h', 'б': 'b', 'л': 'l', 'ц': 'c', 'в': 'v', 'м': 'm', 'ч': 'ch', 'г': 'g', 'н': 'n',
'ш': 'sh', 'д': 'd', 'о': 'o', 'щ': 'shh', 'е': 'e', 'п': 'p', 'ъ': '*', 'ё': 'jo', 'р': 'r', 'ы': 'y', 'ж': 'zh',
'с': 's', 'ь': "'", 'з': 'z', 'т': 't', 'э': 'je', 'и': 'i', 'у': 'u', 'ю': 'ju', 'й': 'j', 'ф': 'f', 'я': 'ya',
'А': 'A', 'К': 'K', 'Х': 'H', 'Б': 'B', 'Л': 'L', 'Ц': 'C', 'В': 'V', 'М': 'M', 'Ч': 'Ch', 'Г': 'G', 'Н': 'N',
'Ш': 'Sh', 'Д': 'D', 'О': 'O', 'Щ': 'Shh', 'Е': 'E', 'П': 'P', 'Ъ': '*', 'Ё': 'Jo', 'Р': 'R', 'Ы': 'Y', 'Ж': 'Zh',
'С': 'S', 'Ь': "'", 'З': 'Z', 'Т': 'T', 'Э': 'Je', 'И': 'I', 'У': 'U', 'Ю': 'Ju', 'Й': 'J', 'Ф': 'F', 'Я': 'Ya'}
filename = input()
with open(filename, 'r', encoding='utf-8') as source, open('result.txt', 'w', encoding='utf-8') as tr_result:
for l in source.read():
trans = translit.get(l.lower(), l)
tr_result.write(trans if l.islower() else trans.capitalize())
Задание 10
Имеется лог-файл crm_log.txt с
информацией о времени входа пользователей в CRM-систему и о времени выхода. Напишите программу, которая
определяет пользователей, работавших в системе более 4 часов, и записывает их
имена и фамилии в файл best_employees.txt.
Пример лога crm_log.txt:
Егор Тимофеев, 09:10, 16:50
Марина Абрамова, 12:00, 15:59
Никита Круглов, 09:10, 12:45
Анна Семенова, 08:10, 12:30
Юлия Сафонова, 10:10, 10:50
Михаил Колесников, 11:10, 12:10
Ожидаемый результат в файле best_employees.txt:
Егор Тимофеев
Анна Семенова
Решение:
with open('crm_log.txt', encoding='utf-8') as file_input, \
open('best_employees.txt', 'w', encoding='utf-8') as file_output:
for line in file_input:
start, end = [int(h) * 60 + int(m) for t in line.split(', ')[1:] for h, m in [t.split(':')]]
if end - start > 240:
file_output.write(line.split(', ')[0] + '\n')
Подведем итоги
Python
предоставляет множество простых и удобных методов для работы с файловой
системой и файлами. С помощью этих методов можно легко:
- Получать любую информацию о файлах и директориях.
- Создавать, изменять, перемещать и удалять директории и файлы.
- Проводить любые операции с содержимым текстовых и двоичных файлов.
В следующей статье будем изучать регулярные выражения.
***
Содержание самоучителя
- Особенности, сферы применения, установка, онлайн IDE
- Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
- Типы данных: преобразование и базовые операции
- Методы работы со строками
- Методы работы со списками и списковыми включениями
- Методы работы со словарями и генераторами словарей
- Методы работы с кортежами
- Методы работы со множествами
- Особенности цикла for
- Условный цикл while
- Функции с позиционными и именованными аргументами
- Анонимные функции
- Рекурсивные функции
- Функции высшего порядка, замыкания и декораторы
- Методы работы с файлами и файловой системой
- Регулярные выражения
- Основы скрапинга и парсинга
- Основы ООП: инкапсуляция и наследование
- Основы ООП – абстракция и полиморфизм
- Графический интерфейс на Tkinter
- Основы разработки игр на Pygame
- Основы работы с SQLite
- Основы веб-разработки на Flask
- Основы работы с NumPy
- Основы анализа данных с Pandas
Пройдите тест, узнайте какой профессии подходите
Работать самостоятельно и не зависеть от других
Работать в команде и рассчитывать на помощь коллег
Организовывать и контролировать процесс работы
Введение в работу с путями файлов в Python
Работа с путями файлов является важным аспектом программирования на Python, особенно когда речь идет о манипуляции файлами и директориями. В Python существует несколько модулей, которые помогают упростить эту задачу, включая os и pathlib. В этой статье мы рассмотрим основные методы и функции, которые помогут вам эффективно работать с путями файлов в Python. Понимание того, как правильно работать с путями файлов, может значительно упростить вашу работу и сделать ваш код более надежным и переносимым.
Использование модуля os для работы с путями
Модуль os предоставляет множество функций для работы с операционной системой, включая функции для работы с путями файлов. Этот модуль является частью стандартной библиотеки Python и широко используется для выполнения различных задач, связанных с операционной системой. Вот некоторые из наиболее часто используемых функций:
os.path.join
Функция os.path.join используется для объединения нескольких компонентов пути в один путь. Это особенно полезно для создания путей, которые будут работать на разных операционных системах. Например, на Unix-системах разделителем путей является /, а на Windows — \. Использование os.path.join позволяет избежать проблем с несовместимостью путей.
os.path.exists
Функция os.path.exists проверяет, существует ли указанный путь. Это полезно для проверки наличия файла или директории перед выполнением операций, которые могут вызвать ошибки, если путь не существует.
os.path.abspath
Функция os.path.abspath возвращает абсолютный путь для указанного относительного пути. Это полезно для получения полного пути к файлу или директории, что может быть необходимо для выполнения определенных операций.
Преимущества и использование модуля pathlib
Модуль pathlib был введен в Python 3.4 и предоставляет объектно-ориентированный подход к работе с путями файлов. Он обладает рядом преимуществ по сравнению с модулем os, таких как более интуитивный и читаемый синтаксис, а также поддержка всех основных операций с путями файлов.
Создание пути
Создание пути с использованием pathlib выглядит более интуитивно и читаемо. Вместо использования строк и функций, вы работаете с объектами, что делает код более понятным и легким для чтения.
Проверка существования пути
Проверка существования пути с использованием pathlib также проста и интуитивна. Вместо вызова функции, вы просто вызываете метод объекта.
Получение абсолютного пути
Получение абсолютного пути с использованием pathlib выполняется с помощью метода resolve. Этот метод возвращает полный путь к файлу или директории.
Получение текущего пути и навигация по файловой системе
Работа с текущим путем и навигация по файловой системе является важной частью работы с путями файлов. Рассмотрим, как это можно сделать с использованием модулей os и pathlib.
Получение текущего пути
С помощью модуля os можно получить текущий рабочий каталог с помощью функции os.getcwd. Это полезно для определения текущего местоположения в файловой системе.
С помощью модуля pathlib можно получить текущий рабочий каталог с помощью метода Path.cwd. Этот метод возвращает объект Path, представляющий текущий рабочий каталог.
Навигация по файловой системе
Навигация по файловой системе может включать переход в другой каталог, создание новых директорий и удаление существующих. Эти операции могут быть выполнены с использованием как модуля os, так и модуля pathlib.
Переход в другой каталог
С помощью модуля os можно изменить текущий рабочий каталог с помощью функции os.chdir. Это полезно для выполнения операций в другом каталоге.
С помощью модуля pathlib можно изменить текущий рабочий каталог с помощью метода chdir. Этот метод изменяет текущий рабочий каталог на указанный путь.
Создание новой директории
С помощью модуля os можно создать новую директорию с помощью функции os.makedirs. Эта функция создает все промежуточные директории, если они не существуют.
С помощью модуля pathlib можно создать новую директорию с помощью метода mkdir. Этот метод также может создавать все промежуточные директории, если указать параметр parents=True.
Удаление директории
С помощью модуля os можно удалить директорию с помощью функции os.rmdir. Эта функция удаляет только пустые директории.
С помощью модуля pathlib можно удалить директорию с помощью метода rmdir. Этот метод также удаляет только пустые директории.
Практические примеры и советы
Пример 1: Создание и удаление файла
Создание и удаление файла является одной из основных операций при работе с путями файлов. Рассмотрим, как это можно сделать с использованием pathlib.
Пример 2: Чтение и запись в файл
Чтение и запись в файл также являются важными операциями. Рассмотрим, как это можно сделать с использованием pathlib.
Совет: Используйте pathlib для новых проектов
Если вы начинаете новый проект или обновляете существующий, рекомендуется использовать модуль pathlib вместо os для работы с путями файлов. pathlib предоставляет более удобный и интуитивно понятный интерфейс, а также поддерживает все основные операции, необходимые для работы с путями файлов. Это делает код более читаемым и легким для сопровождения.
Работа с путями файлов в Python может быть простой и эффективной, если использовать правильные инструменты. Модули os и pathlib предоставляют все необходимые функции для выполнения различных операций с путями файлов, и выбор между ними зависит от ваших предпочтений и требований проекта. Независимо от того, какой модуль вы выберете, важно понимать основные концепции и методы работы с путями файлов, чтобы ваш код был надежным и переносимым.
Читайте также
Порой разработчику приходится отойти от мира программной абстракции и обратиться к практическим вещам. Например, к файловой системе. Манипуляции путями файловых систем в Python 3 реализуется несколькими библиотеками. Одна из них — pathlib. И в этой статье мы хотели бы вам рассказать о том, как использовать модуль pathlib и решать практические задачи с помощью него.
Файловая система
Прежде, чем перейти непосредственно к практической части применения библиотеки pathlib, необходимо повторить матчасть и обсудить основную концепцию файловой системы и её терминологию.
Итак, у нас есть файл example.exe расположенный в C:\Program Files (файловая система Windows). У этого файла есть 4 основные характеристики с точки зрения файловой системы:
- Путь — это идентификатор файла, определяющий его местонахождение в файловой системе, исходя из последовательности названий каталогов. Их разделяют на два типа:
- Абсолютный путь — полный путь файла, начинающийся с корневого каталога. Например, C:\Program Files\example.exe
- Относительный путь — путь к файлу относительно другого каталога. Например, Program Files\example.exe
- Каталог (C:\Program Files) — это объект в файловой системе, необходимой для иерархической организации файловой системы. Иногда его называют директория или папка. Название «папка» отлично описывает практическое название этого объекта — удобное хранение и быстрое нахождение при необходимости.
- Расширение (.exe) — это формат файла. С помощью расширения пользователь или программы определяют тип данных, хранящихся в файле (видео, текст, музыка и т.д.).
Экземпляры Path
Импортируем модуль pathlib для манипуляции путями файловых систем:
from pathlib import *Классы этого модуля можно разбить на два типа: Pure (или «чистые») и Concrete (или «конкретные»). Первые нужны для абстрактной вычислительной работы с путями, при которой не осуществляется непосредственное взаимодействие с файловой системой ОС. Вторые же необходимы для взаимодействия с ней (создания и удаление директорий, чтения файлов и т.д.).
Если вы не уверены, какой класс подходит для выполнения вашей задачи, то, скорее всего, класс Path будет в самый раз. Он позволяет взаимодействовать с файловой системой ОС, под которую сам подстраивается (UNIX или Windows), но и при этом ваша манипуляция путями не страдает от ограничений. В рамках этой статьи мы рассмотрим все классы и их применение, но сосредоточимся конкретно на Path.
Итак, начнем с малого. Создадим переменную с типом данных Path:
>>> PathExample = Path('Timeweb', 'Cloud', 'Pathlib')
>>> PathExample
WindowsPath('Timeweb/Cloud/Pathlib')Как видим, модуль сам подстроился под операционную систему — в нашем случае Windows 10. Конструктор Path(args) создает новый экземпляр класса Path и на вход принимает его компоненты (директории, файлы, другие пути).
Путь PathExample — относительный. Чтобы он стал абсолютным необходимо добавить корневой каталог.
С помощью методов Path.home() и Path.cwd() мы можем получить каталог текущего пользователя и текущую рабочую папку:
>>> Path.home()
WindowsPath('C:/Users/Blog)
>>> Path.cwd()
WindowsPath('C:/Users/Blog/AppData/Local/Programs/Python/Python310')Сделаем PathExample абсолютным и рассмотрим другие аспекты работы с pathlib:
>>> PathExample = Path.home() / PathExample
>>> PathExample
WindowsPath('C:/Users/Blog/Timeweb/Cloud/Pathlib')С помощью оператора «/» мы можем создавать новые пути.
vds
Атрибуты Path
Pathlib предоставляет различные методы и свойства для получения разнообразной информации о путях. Для наглядности добавим введем новую переменную AttributeExample и добавим в неё файл:
>>>AttributeExample = PathExample / 'file.txt'
>>> AttributeExample
WindowsPath('C:/Users/Blog/Timeweb/Cloud/Pathlib/file.txt')Диск
Чтобы узнать букву или имя диска, необходимо использовать свойство.drive:
>>> AttributeExample.drive
'C:'Родительские каталоги
Мы можем получить родительские каталоги с помощью двух свойств: parent и parents[n].
Parent возвращает родительский каталог:
>>> AttributeExample.parent
WindowsPath('C:/Users/Blog/Timeweb/Cloud/Pathlib')Чтобы получить более «высокие» родительские каталоги, можно использовать parent несколько раз:
>>> AttributeExample.parent.parent
WindowsPath('C:/Users/Blog/Timeweb/Cloud')Или воспользоваться свойством parents[n], который возвращает n-го предка:
>>> AttributeExample.parents[3]
WindowsPath('C:/Users/Blog)Имя
Для получения имени файла нужно использовать свойство .name:
>>> AttributeExample.name
'file.txt'Расширение
Для того, чтобы получить расширение файла, необходимо использовать свойство .suffix или .suffixes (при наличии двойного расширения, например .tar.gz):
>>> AttributeExample.suffix
'.txt' >>> Path('file.tar.gz').suffixes
['.tar', '.gz']Абсолютный или относительный путь
Мы можем определить, является ли путь абсолютным, с помощью метода .is_absolute():
>>> AttributeExample.is_absolute()
TrueСоставные части
Мы можем разложить путь на компоненты с помощью свойства .parts:
>>> AttributeExample.parts
('C:\\', 'Users', ‘Blog’, 'Timeweb', 'Cloud', 'Pathlib', 'file.txt')Сравнение путей
Мы можем сравнивать пути как с помощью операторов сравнения, так и с помощью различных методов.
Операторы сравнения
Мы можем узнать, являются ли пути одинаковыми:
>>>Path('timeweb') == Path('TIMEWEB')
True Стоит упомянуть, что такое же сравнение для UNIX-систем будет давать результат False:
>>> PurePosixPath('timeweb') == PurePosixPath('TIMEWEB')
False Это связано с тем, что в Windows регистр не имеет значения в имени директории, в отличие от файловой системы UNIX-систем.
Методы сравнения
Мы можем узнать, является ли один путь частью другого, с помощью метода .is_relative_to():
>>> CompareExample = AttributeExample
>>> CompareExample.is_relative_to('C:')
True >>> CompareExample.is_relative_to('D:/')
FalseТакже можно использовать шаблоны для проверки с помощью метода .match():
>>> CompareExample.match('*.txt')
True Создание и удаление папок и файлов
Для создания папок с помощью модуля pathlib необходимо использовать метод .mkdir(parents = True/False, exist_ok =True/False). Метод получает на вход (помимо пути, по которому нужно создать папку) 2 логические переменные: parents и exist_ok.
Если значение parents = True, то метод создаст родительские каталоги (при их отсутствии). Если False, то вернет ошибку при их отсутствии.
Exist_ok отвечает за обработку ошибок, возникающих при существовании целевой папки.
Создадим папку CreateExample, но сначала проверим, есть ли уже такая директория с помощью метода .is_dir():
>>> CreateExample = CompareExample
>>> CreateExample.is_dir()
FalseТеперь попробуем его создать:
>>> CreateExample.mkdir(parents = True, exist_ok = True)
>>> CreateExample.is_dir()
True Проверим папку в проводнике:
Как видим, появилась именно папка, а не файл. Чтобы создать пустой файл, необходимо использовать метод .touch(). Но сначала удалим папку file.txt с помощью метода .rmdir():
>>> CreateExample.rmdir()
>>> CreateExample.touch()
>>> CreateExample.is_file()
True
Для удаления файлов существует метод .unlink().
Поиск файлов
На основе имеющегося каталога создадим более сложную структуру:
>>> SearchingExample = CreateExample>>> Hosting = Path(SearchingExample.parents[2],'hosting/host.txt')
>>> Hosting.parent.mkdir(parents=True, exist_ok = True)
>>> Hosting.touch()
>>> Docker = Path(SearchingExample.parents[1],'Docker/desk.txt')
>>> Docker.parent.mkdir(parents=True, exist_ok = True)
>>> Docker.touch()
Мы создали и получили такую структуру (начиная с C:\Users\Blog\Timeweb):
Cloud
|— Pathlib
| `— file.txt
`— Docker
`— desk.txt
Hosting
`— host.txtИспользование модуля pathlib для поиска файлов подразумевает применение цикла for и метода .glob():
>>> for file_cloud in SearchingExample.parents[2].glob('*.txt'):
print(file_cloud)Этот код не смог ничего найти, так как он не рассматривал вложенные папки. Чтобы он корректно работал, необходимо его немного изменить:
>>> for file_cloud in SearchingExample.parents[2].glob('**/*.txt'):
print(file_cloud)
...
...
C:\Users\Blog\Timeweb\Cloud\Docker\desk.txt
C:\Users\Blog\Timeweb\Cloud\Pathlib\file.txt
C:\Users\Blog\Timeweb\hosting\host.txtЧтение и запись в файл
Обе операции можно выполнять как в текстовом, так и в бинарном режиме. Мы сосредоточимся на первом варианте. Для работы с содержимым файла pathlib предоставляет 4 метода:
- Чтение: .read_text() и .read_bytes();
- Запись: .write_text() и .write_bytes();
Запишем какую-нибудь важную информацию в файл, которую просто необходимо запомнить. Например, «Timeweb Cloud предлагает очень крутые облачные серверы!». Действительно, такое лучше где-нибудь записать:
>>> WRExample = SearchingExample >>> WRExample.is_file()
True
>>> WRExample.write_text('Timeweb Cloud предлагает очень крутые облачные серверы!')
55 #Длина сообщения
>>> WRExample.read_text()
'Timeweb Cloud предлагает очень крутые облачные серверы!'