Как указать путь к файлу в python windows

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

Путь к файлу в Windows:
C:\some_folder\some_file.txt

В большинстве других ОС:
/some_folder/some_file.txt

Это случайность компьютерной истории начала 1980-х годов. В первой версии MS-DOS для указания параметров командной строки использовался символ прямой косой черты. Когда Microsoft добавила поддержку папок в MS-DOS 2.0, символ прямой косой черты был уже занят, поэтому вместо него использовалась обратная косая черта. Тридцать пять лет спустя мы по-прежнему сталкиваемся с этой несовместимостью.

Если вы хотите, чтобы ваш код на Python работал как на Windows, так и на Mac/Linux, вам придется решать подобные проблемы, связанные с конкретной платформой. К счастью, в Python 3 есть новый модуль pathlib, который делает работу с файлами практически безболезненной.

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

Неправильное решение: построить путь к файлу вручную

Допустим, у вас есть папка, содержащая файл, который вы хотите открыть в вашей программе Python:

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

Сделать так будет неправильно:

data_folder = "source_data/text_files/"

file_to_open = data_folder + "raw_data.txt"

f = open(file_to_open)

print(f.read())

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

Технически этот код будет работать под Windows, потому что в Python есть хак, который распознает любой вид слэша, когда вы вызываете open() под Windows. Но полагаться на это не стоит. Если вы используете тип слэша, не подходящий для ОС, не все библиотеки Python будут работать, особенно если они взаимодействуют с внешними программами или библиотеками.

А поддержка Python для смешивания типов слэшей – это хак только для Windows, который не работает в обратном направлении. Использование обратных слешей в коде будет полностью провальным на Mac:

data_folder = "source_data\\text_files\\"

file_to_open = data_folder + "raw_data.txt"

f = open(file_to_open)

print(f.read())

# На Mac этот код выбросит исключение:
# FileNotFoundError: [Errno 2] No such file or directory: 'source_data\\text_files\\raw_data.txt'

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

Старое решение: построить путь к файлу при помощи модуля os.path

Модуль os.path в Python имеет множество инструментов для решения ОС-специфичных проблем с файловой системой.

Вы можете использовать os.path.join() для построения строки пути, используя нужный вид слэша для текущей операционной системы:

import os.path

data_folder = os.path.join("source_data", "text_files")

file_to_open = os.path.join(data_folder, "raw_data.txt")

f = open(file_to_open)

print(f.read())

Этот код будет отлично работать как на Windows, так и на Mac. Проблема в том, что его сложно использовать. Выписывать os.path.join() и передавать каждую часть пути в виде отдельной строки – многословно и неинтуитивно.

Поскольку большинство функций в модуле os.path так же неудобны в использовании, разработчики часто “забывают” их использовать. Это приводит к множеству кроссплатформенных ошибок и недовольству пользователей.

Лучшее решение: использовать pathlib в Python 3

В Python 3.4 появилась новая стандартная библиотека с модулем pathlib для работы с файлами и путями – и это замечательно!

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

from pathlib import Path

data_folder = Path("source_data/text_files/")

file_to_open = data_folder / "raw_data.txt"

f = open(file_to_open)

print(f.read())

Обратите внимание на два момента:

  • С функциями pathlib нужно использовать прямые слэши. Объект Path() преобразует их в правильный вид слэша для текущей операционной системы. Отлично!
  • Если вы хотите дополнить путь к файлу, можно использовать оператор / непосредственно в коде. Попрощайтесь с беспрестанным набором os.path.join(a, b).

И даже если бы это было всё, на что способен pathlib, это уже было бы отличным дополнением к Python. Но этот модуль способен на большее!

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

from pathlib import Path

data_folder = Path("source_data/text_files/")

file_to_open = data_folder / "raw_data.txt"

print(file_to_open.read_text())

Фактически, pathlib делает большинство стандартных операций с файлами быстрыми и простыми:

from pathlib import Path

filename = Path("source_data/text_files/raw_data.txt")

print(filename.name)
# Выводит "raw_data.txt"

print(filename.suffix)
# Выводит "txt"

print(filename.stem)
# Выводит "raw_data"

if not filename.exists():
    print("Oops, file doesn't exist!")
else:
    print("Yay, the file exists!")

Вы даже можете использовать pathlib для явного преобразования пути Unix в путь в формате Windows:

from pathlib import Path, PureWindowsPath

filename = Path("source_data/text_files/raw_data.txt")

# Конвертировать путь в формат Windows
path_on_windows = PureWindowsPath(filename)

print(path_on_windows)

# Вывод:
# source_data\text_files\raw_data.txt

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

from pathlib import Path, PureWindowsPath

# Я явно объявил мой путь в формате Windows, чтобы использовать в нем прямые слэши.
filename = PureWindowsPath("source_data\\text_files\\raw_data.txt")

# Конвертировать путь в подходящий для текущей ОС формат
correct_path = Path(filename)

print(correct_path)
# Выводит "source_data/text_files/raw_data.txt" на Mac и Linux
# Выводит "source_data\text_files\raw_data.txt" на Windows

Проявив смекалку, можно использовать pathlib даже для разрешения относительных путей к файлам, разбора путей к сетевым ресурсам и генерации URL file://. Вот пример из всего пары строк кода, которые откроют локальный файл в вашем браузере:

from pathlib import Path
import webbrowser

filename = Path("source_data/text_files/raw_data.txt")

webbrowser.open(filename.absolute().as_uri())

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

Спасибо за чтение!

Перевод статьи Adam Geitgey «Python 3 Quick Tip: The easy way to deal with file paths on Windows, Mac and Linux».

путь к файлу в Python

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

Самый простой вариант — не самый верный!

Внимание! У этого способа обнаружен недостаток!

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

Пример относительного пути:
path = "Files/info.txt" # в Линуксе, или:
path = "Files\info.txt" # в Windows

Где вместо «Files» и «info.txt» Вы напишите названия ваших директорий и имя вашего файла соответственно.

Пример абсолютного пути:
path = "/home/my_comp/Files/info.txt" # для Линукс, или:
path = "C:\Python\pythonw.exe\Files\info.txt" # для Windows

Где вместо «C:\Python\pythonw.exe\Files\info.txt», «home/my_comp/Files/» и «info.txt» Вы напишите названия ваших директорий и имя вашего файла соответственно.

Этот вариант рабочий, однако, один существенный недостаток лишил его внимания разработчиков. Проблема заключается в том, что заданные таким способом пути адаптированы только к одному виду операционной системы: к Линукс, либо к Windows, так как в Windows используются обратные слеши «\», а в Линукс — обычные «/». Из-за этого скрипт, показывавший отличные результаты в Windows, начнет жаловаться на отсутствие файлов по прописанному пути в Linux, и наоборот. А с абсолютным путем вообще все сложно: никакого диска «C:» в Линуксе нет. Скрипт опять будет ругаться! Что же делать? Правильно указать путь к файлу!

Указываем путь к файлу правильно!

Внимание! Годный вариант!

Python — умный змей, поэтому в его арсенале, начиная с 3.4 версии появился модуль pathlib, который позволяет вытворять самые приятные вещи с путями к файлу, стоит только импортировать его класс Path:

import pathlib
from pathlib import Path

Кстати, если у вас не установлен модуль pathlib, это легко исправить с помощью команды:

pip install pathlib

Задаем относительный путь с помощью Path!

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

Например, в случае расположения файлов, как на представленном изображении, относительный путь, определяемый в скрипте «main_script.py», сформируется автоматически из перечисленных в скобках составных частей. Pathlib инициализирует новый объект класса Path, содержимым которого станет сформированный для Вашей системы относительный путь (в Windows части пути будут разделены обратными слешами, в Linux — обычными):

import pathlib
from pathlib import Path  
path = Path("files", "info", "docs.txt") 

## выведем значение переменной path:
print(str(path))
## выведем значение переменной path:
files/info/docs.txt  

У нас появился Telegram-канал для изучающих Python! Канал совсем свежий, подпишись одним из первых, ведь вместе «питонить» веселее! 😉 Ссылка на канал: «Кодим на Python!»

Задаем абсолютный путь с помощью Path

  • cwd() — возвращает путь к рабочей директории
  • home() — возвращает путь к домашней директории

Полученную строку, содержащую путь к рабочей или домашней директории, объединим с недостающими участками пути при инициализации объекта класса Path :

Пример 1: с использованием функции cwd():
import pathlib
from pathlib import Path

#Получаем строку, содержащую путь к рабочей директории:
dir_path = pathlib.Path.cwd()

# Объединяем полученную строку с недостающими частями пути
path = Path(dir_path, 'files','info', 'docs.txt')

# выведем значение переменной path:
print(str(path))
# выведем значение переменной path:
"/home/my_comp/python/files/info/docs.txt"

В данном случае путь к директории имеет вид: dir_path = «/home/my_comp/python», а полный путь к файлу «docs.txt» будет иметь вид: «/home/my_comp/python/files/info/docs.txt».

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

import pathlib
from pathlib import Path
path = Path(pathlib.Path.cwd(), 'files', 'info', 'docs.txt')

# значение переменной path:
print(str(path))
# значение переменной path:
"/home/my_comp/python/files/info/docs.txt"
Пример2: с использованием функции home():
import pathlib
from pathlib import Path

#Получаем строку, содержащую путь к домашней директории:
dir_path = pathlib.Path.home()

# Объединяем полученную строку с недостающими частями пути
path = Path(dir_path, 'files','info', 'docs.txt')

# Выведем значение переменной path:
print(str(path))
# Выведем значение переменной path:
"/home/my_comp/files/info/docs.txt"

В данном случае путь к директории имеет вид: dir_path = «/home/my_comp», а полный путь к файлу ‘docs.txt’ будет иметь вид: «/home/my_comp/files/info/docs.txt».

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

import pathlib
from pathlib import Path
path = Path(pathlib.Path.home(), 'files', 'info', 'docs.txt')

# Значение переменной path:
print(str(path))
# Значение переменной path:
"/home/my_comp/files/info/docs.txt"

Подведем итог: начиная с версии Python 3.4, для задания пути к файлу рекомендуется использовать модуль pathlib с классом Path. Определить путь к рабочей директории можно с помощью функции cwd(), а путь к домашней директории подскажет функция home().

Время на прочтение
10 мин

Количество просмотров 25K

В каждой операционной системе существуют свои правила построения путей к файлам. Например, в 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.

Классы PurePath()

Классы PurePath()

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 как указать путь к файлу

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

Абсолютный путь

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

    
    with open('C:\\Users\\Username\\Desktop\\file.txt', 'r') as f:
        print(f.read())
    

Относительный путь

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

    
    with open('file.txt', 'r') as f:
        print(f.read())
    

Модуль os

Для работы с путями в Python есть специальный модуль os, который предоставляет ряд полезных функций:

    
    import os

    path = os.path.join('folder1', 'folder2', 'file.txt')
    with open(path, 'r') as f:
        print(f.read())
    

Функция os.path.join позволяет соединять различные части пути с учетом особенностей операционной системы, на которой выполняется код.

python как указать путь к файлу

Для работы с файловой системой в 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'

    

Получение информации о файлах и директориях

Метод 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

Для создания новых каталогов используют два метода:

  • 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
предоставляет множество простых и удобных методов для работы с файловой
системой и файлами. С помощью этих методов можно легко:

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

В следующей статье будем изучать регулярные выражения.

***

Содержание самоучителя

  1. Особенности, сферы применения, установка, онлайн IDE
  2. Все, что нужно для изучения Python с нуля – книги, сайты, каналы и курсы
  3. Типы данных: преобразование и базовые операции
  4. Методы работы со строками
  5. Методы работы со списками и списковыми включениями
  6. Методы работы со словарями и генераторами словарей
  7. Методы работы с кортежами
  8. Методы работы со множествами
  9. Особенности цикла for
  10. Условный цикл while
  11. Функции с позиционными и именованными аргументами
  12. Анонимные функции
  13. Рекурсивные функции
  14. Функции высшего порядка, замыкания и декораторы
  15. Методы работы с файлами и файловой системой
  16. Регулярные выражения
  17. Основы скрапинга и парсинга
  18. Основы ООП: инкапсуляция и наследование
  19. Основы ООП – абстракция и полиморфизм
  20. Графический интерфейс на Tkinter
  21. Основы разработки игр на Pygame
  22. Основы работы с SQLite
  23. Основы веб-разработки на Flask
  24. Основы работы с NumPy
  25. Основы анализа данных с Pandas

***

  • Как указать путь к драйверу на windows 10
  • Как указать путь загрузки windows 10
  • Как указать прокси в windows 10
  • Как указать относительный путь к файлу windows
  • Как указать диск для загрузки windows 10