Работа с файлами в питоне: примеры кода для работы с путями в Питон 3

Содержание

Полный курс по изучению Tkinter + Примеры

В Python есть довольно много GUI фреймворков (graphical user interface), однако только Tkinter встроен в стандартную библиотеку языка. У Tkinter есть несколько преимуществ. Он кроссплатформенный, поэтому один и тот же код можно использовать на Windows, macOS и Linux.

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

Хотя Tkinter является популярным GUI фреймворком на Python, у него есть свои недостатки. Один из них заключается в том, что графические интерфейсы, созданные с использованием Tkinter, выглядят устаревшими. Если вам нужен современный, броский интерфейс, то Tkinter может оказаться не совсем тем, для этого есть PyQt5 который развивается сильнее в данном плане.

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

Другие статьи по Tkinter на сайте

  1. Создание окна по центру и кнопка выхода в Tkinter
  2. Разметка виджетов в Tkinter — pack, grid и place
  3. Виджеты Checkbutton, Label, Scale и Listbox в Tkinter
  4. Меню, подменю и панель инструментов в Tkinter
  5. Диалоговые окна в Tkinter
  6. Рисуем линии, прямоугольники, круг и текст в Tkinter
  7. Пишем игру змейка на Tkinter

Основные аспекты руководства

  • Введение и создание простого приложения «Hello, World!» в Tkinter;
  • Работа с виджетами вроде кнопок или текстовых боксов;
  • Управление макетом приложений через геометрические менеджеры;
  • Создание интерактивного приложения через связывание кнопок с функциями Python.

После освоения основных навыков в процессе изучения примеров, данных в руководстве, вы сможете создать два рабочих приложения. Одно будет конвертером температуры, а второе редактором текста. Что ж, приступим!

Создание простого GUI приложения на Tkinter

Главным элементом GUI Tkinter является окно. Окнами называют контейнеры, в которых находятся все GUI элементы. Данные GUI элементы, к числу которых относятся текстовые боксы, ярлыки и кнопки, называются

виджетами. Виджеты помещаются внутри окон.

Сперва создадим окно с одним виджетом. Запустим новую сессию оболочки Python, следуя инструкции.

На заметку: Примеры кода, используемые в руководстве, были протестированы на Windows, macOS и Ubuntu Linux 18.04 через версии Python 3.6, 3.7 и 3.8.

В случае, если вы установили Python на Windows или macOS, скачав установщик c официального сайта python.org, проблем с запуском кода из примеров возникнуть не должно. Можете пропустить оставшуюся часть заметки и перейти к самому руководству.

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

Установка Python на macOS используя Homebrew:

Дистрибутив Python для macOS, доступный на Homebrew, поставляется без библиотеки Tcl/Tk с Tkinter. Вместо этого используется версия системы по умолчанию. Версия может быть устаревшей и не позволяющей импортировать модуль Tkinter в Python. Во избежание такой проблемы, используйте официальный установщик macOS.

Ubuntu Linux 16.04:

Последняя версия Python доступна на Ubuntu Linux 16.04, это 3.5. Вы можете установить последнюю версию через deadsnakes PPA. Далее даны команды для установки PPA и загрузки последней версии Python с правильной версией Tcl/Tk:

$ sudo add-apt-repository ppa:deadsnakes/ppa $ sudo apt-get update $ sudo apt-get install python3.8 python3-tk

$ sudo add-apt-repository ppa:deadsnakes/ppa

$ sudo apt-get update

$ sudo apt-get install python3.8 python3-tk

Первые две команды добавляют deadsnakes PPA в ваш системный список репозитория, а последняя команда устанавливает Python 3.8 и модуль GUI Tkinter.

Ubuntu Linux 18.04:

Вы можете установить последнюю версию Python с соответствующей версией Tcl/Tk из универсального репозитория через следующую команду:

$ sudo apt-get install python3.8 python3-tk

$ sudo apt-get install python3.8 python3-tk

Таким образом устанавливается Python 3.8, а также модуль Tkinter.

Прочие версии Linux:

Если на данный момент нет официального рабочего установщика Python для Linux дистрибутива, то можете поставить Python вместе с соответствующей версией Tcl/Tk через исходный код. С пошаговой инструкцией процесса можете ознакомиться на странице: Установка Python 3.8 из исходного кода на Linux

В открытой оболочке IDLE Python первым делом необходимо импортировать модуль Tkinter:

Окно, или window является экземпляром класса Tkinter. Попробуйте создать новое окно, присвоив его переменной окна window:

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

Далее в руководстве будут представлены примеры из операционной системы Ubuntu и Windows.

Добавление нового виджета в приложении

Теперь, когда у вас есть окно, можно добавить на него виджет. Используем класс tk.Label и добавим какой либо текст на окно.

Создадим виджет ярлыка (label) с текстом "Привет, Tkinter!" и присвоим его переменной под названием

greeting:

>>> greeting = tk.Label(text="Привет, Tkinter!")

>>> greeting = tk.Label(text="Привет, Tkinter!")

Созданное ранее окно не меняется. Создается виджет ярлыка, однако пока не добавляется на окно. Есть несколько способов добавления виджетов на окно. Сейчас можно использовать метод .pack() от виджета ярлыка:

Теперь окно выглядит следующим образом:

При использовании метода .pack() для размещения виджета в окне, Tkinter устанавливает размер окна настолько маленьким, насколько возможно, пока в него не влезает виджет. Теперь выполним следующее:

Кажется, будто ничего не случилось, но это не совсем так. window.mainloop() указывает Python, что нужно запустить цикл событий Tkinter. Данный метод требуется для событий вроде нажатий на клавиши или кнопки, он также блокирует запуск любого кода, что следует после, пока окно, на котором оно было вызвано, не будет закрыто. Попробуйте закрыть созданное окно, и вы увидите появившуюся в оболочке подсказку.

Внимание

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

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

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

Задание #1 Создать обычное окно в Tkinter

Выполните небольшое задание, чтобы проверить свои знания.

Напишите полный скрипт для создания окна в Tkinter с текстом «Python рулит!». Окно должно выглядеть следующим образом:

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

Код с решением


import tkinter as tk window = tk.Tk() label = tk.Label(text="Python рулит!") label.pack() window.mainloop()

import tkinter as tk

 

window = tk.Tk()

label = tk.Label(text="Python рулит!")

label.pack()

 

window.mainloop()


Работа с виджетами в Tkinter

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

Класс виджетаОписание
LabelИспользуется для отображения текста или вставки изображения на окне приложения.
ButtonКнопка, на которой может быть текст, совершает определенные действия при нажатии на нее.
EntryВиджет для ввода одной строчки текста. Эквивалент <input type="text"> в HTML.
TextВиджет для ввода большого текста. Эквивалент <textarea> в HTML.
FrameПрямоугольная область, что используется для группировки виджетов или для добавления расстояния между виджетами.

В дальнейшем, мы на практике рассмотрим, как действует каждый из представленных выше виджетов. С более подробными списками виджетов Tkinter можете ознакомиться на страницах Basic Widgets и More Widgets. А пока рассмотрим подробнее виджет ярлыка Label.

Виджет Label — Отображение текста и картинок

Виджеты Label используется для отображения текста или картинок. Текст на виджете Label, не может редактироваться пользователем. Он только показывается. Как было показано в примере в начале данного руководства, виджет Label можно создать через экземпляр класса Label и передачу строки в параметр text:

label = tk.Label(text="Hello, Tkinter")

label = tk.Label(text="Hello, Tkinter")

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

Изменить цвет текста и фона виджета Label

можно через параметры foreground и background:

label = tk.Label( text="Привет, Tkinter!", foreground="white", # Устанавливает белый текст background="black" # Устанавливает черный фон )

label = tk.Label(

    text="Привет, Tkinter!",

    foreground="white",  # Устанавливает белый текст

    background="black"  # Устанавливает черный фон

)

Некоторые доступные цвета:

  • red — красный;
  • orange — оранжевый;
  • yellow — желтый;
  • green — зеленый;
  • blue — синий;
  • purple — сиреневый.

Многие HTML-цвета имеют такое же название в Tkinter. Со списком доступных названий цветов можете ознакомиться здесь.

Если хотите подробнее разобраться в теме, особенно в системных цветах macOS и Windows, контролируемых текущей темой ОС, ознакомьтесь со страницей значений цветов.

Вы также можете указать цвет, используя шестнадцатеричные значения RGB такое часто используется в CSS для стилизации сайтов:

label = tk.Label(text="Привет, Tkinter!", background="#34A2FE")

label = tk.Label(text="Привет, Tkinter!", background="#34A2FE")

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

Если вам не хочется регулярно вводить foreground и background, можете использовать сокращенные версии параметров — fg и bg. Они точно также отвечают за установку цвета текста и цвета фона.

label = tk.Label(text="Привет, Tkinter!", fg="white", bg="black")

label = tk.Label(text="Привет, Tkinter!", fg="white", bg="black")

Вы также можете управлять шириной и высотой ярлыка с помощью параметров width и height:

import tkinter as tk window = tk.Tk() label = tk.Label( text="Привет, Tkinter!", fg="white", bg="black", width=20, height=20 ) label.pack() window.mainloop()

import tkinter as tk

 

window = tk.Tk()

 

label = tk.Label(

    text="Привет, Tkinter!",

    fg="white",

    bg="black",

    width=20,

    height=20

)

 

label.pack()

window.mainloop()

В окне, ярлык будет выглядеть следующим образом:

Может показаться странным, что ярлык в окне не является квадратным, хотя параметр как ширины, так и высоты равен 20. Все оттого, что ширина и высота измеряются в текстовых юнитах.

Горизонтальный текстовый юнит определен шириной символа "0", или цифрой ноль, в шрифте системы по умолчанию. Аналогичным образом один вертикальный текстовый юнит определен высотой символа "0".

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

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

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

Создание кнопки через виджет Button

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

Существует много сходств между виджетами Button и Label. По сути кнопка — это просто ярлык, на который можно кликнуть. Для создания стилей виджетов ярлыка и кнопки также используются одинаковые аргументы.

К примеру, следующий код создает кнопку с синим фоном и желтым текстом. Также устанавливается ширина и высота с показателями в 25 и 5 текстовых юнит:

import tkinter as tk window = tk.Tk() button = tk.Button( text="Нажми на меня!", width=25, height=5, bg="blue", fg="yellow", ) button.pack() window.mainloop()

import tkinter as tk

 

window = tk.Tk()

 

button = tk.Button(

    text="Нажми на меня!",

    width=25,

    height=5,

    bg="blue",

    fg="yellow",

)

 

button.pack()

window.mainloop()

Готовая кнопка будет выглядеть следующим образом:

Неплохо! Следующие два виджета Entry и Text используются для сбора вводных данных от пользователя.

Виджет Entry — Однострочное текстовое поле

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

Создание виджета Entry практически ничем не отличается от процесса создания ярлыка и кнопки. К примеру, следующий код создает виджет с синим фоном и желтым текстом длиной в 50 текстовых юнит:

entry = tk.Entry(fg="yellow", bg="blue", width=50)

entry = tk.Entry(fg="yellow", bg="blue", width=50)

В случае виджета однострочного текстового поля (Entry) интересен не процесс создания стиля, а то, как получить эти входные данные от пользователя. Есть три основные операции, что можно провести с виджетом однострочного текстового поля (Entry):

  • Получение всего текста через .get()
  • Удаление текста через .delete()
  • Вставка нового текста через .insert()

Для лучшего понимания принципа работы виджетов Entry создадим один экземпляр элемента и попробуем ввести в него текст. Откройте оболочку Python и выполните следующие действия. Сначала импортируем tkinter и создаем новое окно:

>>> import tkinter as tk >>> window = tk.Tk()

>>> import tkinter as tk

>>> window = tk.Tk()

Теперь создаем виджеты Label и Entry:

>>> label = tk.Label(text="Имя") >>> entry = tk.Entry()

>>> label = tk.Label(text="Имя")

>>> entry = tk.Entry()

Здесь ярлык указывает, что именно пользователь должен записать в виджете Entry. Нет никаких ограничений для вводимых данных, это просто подсказка, что ввести нужно «Имя». Виджеты станут видимыми на окне после выполнения метода .pack() для каждого из них:

>>> label.pack() >>> entry.pack()

>>> label.pack()

>>> entry.pack()

Результат выглядит следующим образом:

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

На созданном в программе виджете мы ввели текст «Иван Иванов»:

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

>>> name = entry.get() >>> name 'Иван Иванов'

>>> name = entry.get()

>>> name

'Иван Иванов'

Текст также можно удалить, для этого используется метод .delete(). Данный метод принимает аргумент, который является целым числом и сообщает Python, какой символ нужно удалить. К примеру, во фрагменте кода ниже показано, как через метод .delete(0) можно удалить первый символ из текстового поля:

Теперь в виджете остался текст "ван Иванов":

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

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

Теперь остался только текст "Иванов":

Метод .delete() работает по аналогии с методом строк slice() для удаления части символов из строки. Первый аргумент определяет начальный индекс удаления, последний индекс указывает где именно процесс удаления должен остановиться.

Для удаления всего текста из текстового поля во втором аргументе метода .delete() используется специальная константа tk.END:

>>> entry.delete(0, tk.END)

>>> entry.delete(0, tk.END)

Теперь остался пустой текстовый бокс:

 

Вы также можете вставить текст в виджете однострочного текстового поля с помощью метода .insert():

>>> entry.insert(0, "Иванов")

>>> entry.insert(0, "Иванов")

Теперь окно стало таким:

 

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

К примеру, при вызове .insert() с первым аргументом 100, а не 0, как было сделано выше, вывод будет тем же.

В том случае, если текстовое поле уже содержит какой-то текст, тогда .insert() вставить новый текст в указанную позицию и сдвинет существующий текст вправо:

>>> entry.insert(0, "Иван ")

>>> entry.insert(0, "Иван ")

В виджете с текстом теперь значится "Иван Иванов":

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

Виджет Text — ввод большого текста в Tkinter

Виджеты Text используются для ввода текста, как и виджеты Entry. Разница в том, что Text может содержать несколько строчек текста. С виджетом Text пользователь может вводить целые параграфы или страницы текста. Как и в случае с виджетами Entry, над виджетами Text можно провести три основные операции:

  • Получение текста через метод .get()
  • Удаление текста через метод .delete()
  • Вставка текста через метод .insert()

Несмотря на то, что названия методов совпадают с теми, что используются в Entry, процесс реализации несколько различен. Разберем пример создания виджета Text и посмотрим на деле, что он может делать.

На заметку: У вас все еще открыто предыдущее окно? Если это так, тогда закройте его, выполнив следующую команду:

Это также можно сделать вручную, просто нажав на кнопку «Закрыть».

В оболочке Python нужно создать новое пустое окно, а внутри нее с помощью метода .pack() разместить текстовой виджет:

>>> import tkinter as tk >>> window = tk.Tk() >>> text_box = tk.Text() >>> text_box.pack()

>>> import tkinter as tk

>>> window = tk.Tk()

>>> text_box = tk.Text()

>>> text_box.pack()

По умолчанию текстовые боксы значительно больше виджетов однострочного ввода текста Entry. Созданное с помощью кода выше окно будет выглядеть следующим образом:

Для активации текстового бокса нажмите на любую точку внутри окна. Введите слово "Hello". Нажмите на клавиатуре кнопку Enter, после чего введите на второй строке слово "World". Окно будет выглядеть следующим образом:

Как и в случае с виджетами Entry, вы можете получить текст их виджета Text с помощью метода .get(). Однако, вызов .get() без аргументов не возвращает весь текст как это происходит с виджетами однострочного ввода текста Entry. Появится исключение TypeError:

>>> text_box.get() Traceback (most recent call last): File "<pyshell#4>", line 1, in <module> text_box.get() TypeError: get() missing 1 required positional argument: 'index1'

>>> text_box.get()

Traceback (most recent call last):

  File "<pyshell#4>", line 1, in <module>

    text_box.get()

TypeError: get() missing 1 required positional argument: 'index1'

Метод .get() для текстового виджета запрашивает хотя бы оди

Работа с файлами при помощи Python

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

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

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

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

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

ManageFiles/
 |
 |_RandomFiles/

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

ManageFiles/
 |
 |_ create_random_files.py
 |_RandomFiles/

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

import os
from pathlib import Path
import random

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

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

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

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

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

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

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

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

python create_random_files.py

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

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

Способ 1

import os
import shutil
import glob

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

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

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

print(set(file_extensions))

file_types = set(file_extensions)

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

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

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

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

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

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

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

os.path.splitext(our_file)[1]

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

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

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

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

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

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

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

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

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

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

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

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

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

shutil.move(fname, new_directory)

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

Способ 2

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

import os
import shutil
import glob

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

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

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

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

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

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

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

Модуль OS и работа с файловой системой

Модуль OS и работа с файловой системой

Последнее обновление: 02.05.2017

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

  • mkdir(): создает новую папку

  • rmdir(): удаляет папку

  • rename(): переименовывает файл

  • remove(): удаляет файл

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

Для создания папки применяется функция mkdir(), в которую передается путь к создаваемой папке:


import os

# путь относительно текущего скрипта
os.mkdir("hello")
# абсолютный путь
os.mkdir("c://somedir")
os.mkdir("c://somedir/hello")

Для удаления папки используется функция rmdir(), в которую передается путь к удаляемой папке:


import os

# путь относительно текущего скрипта
os.rmdir("hello")
# абсолютный путь
os.rmdir("c://somedir/hello")

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

Для переименования вызывается функция rename(source, target), первый параметр которой - путь к исходному файлу, а второй - новое имя файла. В качестве путей могут использоваться как абсолютные, так и относительные. Например, пусть в папке C://SomeDir/ располагается файл somefile.txt. Переименуем его в файл "hello.txt":


import os

os.rename("C://SomeDir/somefile.txt", "C://SomeDir/hello.txt")

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

Для удаления вызывается функция remove(), в которую передается путь к файлу:


import os

os.remove("C://SomeDir/hello.txt")

Существование файла

Если мы попытаемся открыть файл, который не существует, то Python выбросит исключение FileNotFoundError. Для отлова исключения мы можем использовать конструкцию try...except. Однако можно уже до открытия файла проверить, существует ли он или нет с помощью метода os.path.exists(path). В этот метод передается путь, который необходимо проверить:


filename = input("Введите путь к файлу: ")
if os.path.exists(filename):
    print("Указанный файл существует") 
else:
    print("Файл не существует") 

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

Файлы в Python

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

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

Открывает файл и возвращает представляющий его объект.

Режимы открытия файла
r открытие файла на чтение
w открытие файла на запись, содержимое файла удаляется, если файла не существует, создается новый
x открытие файла на запись, если файла не существует. Если файл существует, возникает исключение
a открытие файла на запись, информация добавляется в конец файла
b открытие файла в двоичном режиме
t открытие файла в текстовом режиме
+ открытие файла на чтение и запись
Методы объекта файла

file.read([size])

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

file.write(content)

Записывает информацию в файл

file.tell()

Возвращает текущий указатель внутри файла

file.seek(position, [from_what=0])

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

Второй, необязательный аргумент — это from_what. С помощью него можно указать, откуда следует переместить указатель: 0 — от начала файла, 1 — от текущей позиции и 2 — от конца файла. По‑умолчанию этот аргумент принимает значение 0

file.close()

Закрывает файл. Обязательно вызывайте этот метод после окончания работы с файлом.

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

python-scripts.com

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

автор

9-12 минут


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

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

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

This is test file

line 2

line 3

this line intentionally left lank

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

handle = open("test.txt")

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

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

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

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

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

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

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

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

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

data = handle.read()

print(data)

handle.close()

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

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

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

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

print(data)

handle.close()

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

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

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

print(data)

handle.close()

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

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

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

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

for line in handle:

    print(line)

handle.close()

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

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

while True:

    data = handle.read(1024)

    print(data)

    if not data:

        break

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

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

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

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

Мы изменили способ доступа к файлу на rb, что значит read-binaryy. Стоит отметить то, что вам может понадобиться читать бинарные файлы, когда вы качаете PDF файлы из интернете, или обмениваетесь ими между компьютерами.

Пишем в файлах в Python

Как вы могли догадаться, следуя логике написанного выше, режимы написания файлов в Python это “w” и “wb” для write-mode и write-binary-mode соответственно. Теперь давайте взглянем на простой пример того, как они применяются.
ВНИМАНИЕ: использование режимов “w” или “wb” в уже существующем файле изменит его без предупреждения. Вы можете посмотреть, существует ли файл, открыв его при помощи модуля ОС Python.

handle = open("output.txt", "w")

handle.write("This is a test!")

handle.close()

Вот так вот просто. Все, что мы здесь сделали – это изменили режим файла на “w” и указали метод написания в файловом дескрипторе, чтобы написать какой-либо текст в теле файла. Файловый дескриптор также имеет метод writelines (написание строк), который будет принимать список строк, который дескриптор, в свою очередь, будет записывать по порядку на диск.

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

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

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

    for line in file_handler:

        print(line)

Синтаксис для оператора with, на первый взгляд, кажется слегка необычным, однако это вопрос недолгой практики. Фактически, все, что мы делаем в данном примере, это:

handle = open("test.txt")

Меняем на это:

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

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

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

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

try:

    file_handler = open("test.txt")

    for line in file_handler:

        print(line)

except IOError:

    print("An IOError has occurred!")

finally:

    file_handler.close()

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

try:

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

    for line in file_handler:

        print(line)

except IOError:

    print("An IOError has occurred!")

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

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

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

функция open, чтение и запись в файлы в Python

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

Как открыть файл?

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

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

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

Первым делом нужно вызвать open(), в скобках передать функции, имя внешнего файла и режим работы с ним:

  • r – означает, что по умолчанию откроется режим чтения;
  • w – режим записи в файлы в Python;
  • a – для записи информации в самый конец документа;
  • b – обработка двоичных файлов;
  • знак «+» означает чтение и запись одновременно.

Важное правило – все аргументы нужно указывать как литералы строк, то есть в кавычках и через запятую:

  • >>>This_file = open(«C:\odd», «w») #Пример вызова функции open в интегрированной среде разработки.

Как использовать файлы?

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

Список наиболее используемых операций:

  • input.read() – вернет информацию в качестве единой строки;
  • input.readline() – прочитать следующую строку;
  • input.readlines() – представить файл для чтения целиком со списком строк;
  • .write() – запись строк;
  • .writelines() – запись всех строк;
  • .close() – вручную закрыть документ.

Особенности работы с файлами

Вся информация, содержащаяся внутри файлов, представлена в виде строковых объектов. Поэтому прежде чем приступить к ее обработке, нужно выполнить преобразование данных. Используйте для этого встроенные методы int() или list(). А также выражения для форматирования строк.

Использовать метод close необязательно. Но при работе с flush освобождаются ресурсы ОС и происходит выталкивание выходных буферов. По умолчанию вывод происходит посредством промежуточных буферов. Когда осуществляется запись в файл в Python, информация не сразу попадает на диск, а только в момент закрытия.

Пример записи в файл

Разберем пример работы с текстовым файлом в интерактивном сеансе. Первый шаг – это открыть файл в IDLE. Предварительно его создавать нет необходимости:

  • >>>первый_ф = open(«первый_файл.txt», «w»)
  • >>>первый_ф.write(«Любой текст\n») #Записываем строки
  • 12
  • >>>первый_ф.write(«И снова любой текст\n»)
  • 20
  • >>>первый_ф.close() #Закрываем;
  • >>>первый_ф = open(«первый_файл.txt»)
  • >>>первый_ф.readline() #Читаем, то, что записано
  • «Любой текст\n»

После записи строки в файл, Python 3.0 возвращает число введенных символов. В предыдущей версии этого не происходит. В примере использовался символ конца строки \n. Без него метод write запишет все сплошным текстом.

Если вы хотите прочесть содержимое файла без указания \n в конце, воспользуйтесь методом read:

  • >>>print(open(«первый_файл.txt»).read())
  • любой текст;
  • и снова любой текст;

Просмотреть каждую строку поочередно можно посредством итерации:

  • >>>for x in open(«первый_файл.txt»):
  • print(x, end = « »)
  • любой текст
  • и снова любой текст #Каждая новая строка будет выведена с отступом.

Сохранение базовых объектов языка Python в файл

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

  • >>>пример_2 = open(«второй_файл.txt», «w»)
  • >>>Список = [1,8, «r»]
  • >>>C, B, P = 34, 90, 56
  • >>>Стр = «Набор символов»
  • >>>пример_2.write(str(Список) + «\n»)
  • 12
  • >>>пример_2.write(«%s, %s, %s\n» % (C, B, P))
  • 11
  • >>>пример_2.write(Стр + «\n»)
  • 15
  • >>>пример_2.close()
  • >>>print(open(«второй_файл.txt»).read())
  • [1, 8, «r»]
  • 34, 90, 56
  • набор символов

В этом примере сначала создается новый файловый объект «второй_файл.txt» для записи. Пяти именам присваиваются значения списка, строки и целых чисел. Перед записью каждый объект преобразуется в строку. В конце файл открывается с помощью встроенной функции print и метода read.

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

Преобразовать строки в объекты языка поможет метод readline:

  • >>>L = open(«второй_файл.txt»)
  • >>>F = L.readline()
  • >>>F
  • «34, 90, 56\n»
  • >>>Numbers = F.split(«,») #По запятым разбить на подстроки
  • >>>Numbers
  • [«34», «90», «56\n»]
  • >>>Numbers = [int(x) for x in Numbers] #Преобразовать весь список
  • >>>Numbers
  • [34, 90, 56]

Запись объектов с помощью специальных модулей

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

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

  • >>>Словарь = {«восемь»: 8, «три»: 3, «ноль»: 0}
  • >>>Словарь
  • {«восемь»: 8, «три»: 3, «ноль»: 0}
  • >>>документ = open(«мой_документ.pkl», «wb»)
  • >>>import pickle
  • >>>pickle.dump(Словарь, документ)
  • >>>документ.close()
  • >>>документ = open(«мой_документ.pkl», «rb»)
  • >>>Д = pickle.load(документ)
  • >>>Д
  • {«восемь»: 8, «три»: 3, «ноль»: 0}

С модулем нет необходимости извлекать и преобразовывать данные вручную. Он сам выполняет сериализацию объектов в строку байтов и обратно. Для этого в аргументах open указывается wb – write binary.

Аналогично pickle, «консервировать» данные можно с помощью модуля Python – JSON. Запись в файл осуществляется методом dump. В качестве аргументов указываются сохраняемые объекты, которые автоматически сериализуются в строку JSON-формата.

  • >>>import json
  • >>>Словарь = {«восемь»: 8, «три»: 3, «ноль»: 0}
  • >>>with open(«мой_документ.json», «w») as м_д:
  • >>>json.dump(Словарь, м_д)

Существуют и более сложные способы работы с файлами. Например, операция сканирования, организация циклов записи. Чтобы увидеть весь перечень методов, воспользуйтесь в интерактивном сеансе функциями help или dir. Также в арсенале языка есть объекты, похожие на файлы, - сокеты, потоки командной оболочки и ввода-вывода.

Загрузка файлов из Интернета с использованием Python

Requests - это универсальная HTTP-библиотека на Python с различными приложениями. Одно из его приложений - загрузка файла из Интернета с использованием URL-адреса файла.
Установка: Прежде всего, вам нужно скачать библиотеку запросов. Вы можете напрямую установить его с помощью pip, набрав следующую команду:

 запросов на установку пипса 

Или скачайте прямо отсюда и установите вручную.

Скачивание файлов

Этот небольшой фрагмент кода, написанный выше, загрузит следующее изображение из Интернета. Теперь проверьте свой локальный каталог (папку, в которой находится этот скрипт), и вы найдете это изображение:

Все, что нам нужно, это URL-адрес источника изображения. (Вы можете получить URL-адрес источника изображения, щелкнув изображение правой кнопкой мыши и выбрав параметр «Просмотр изображения».)


Загрузить большие файлы

Содержимое ответа HTTP ( r.content ) - это не что иное, как строка, в которой хранятся данные файла. Таким образом, в случае больших файлов будет невозможно сохранить все данные в одной строке. Чтобы решить эту проблему, мы вносим некоторые изменения в нашу программу:

  • Поскольку все данные файла не могут храниться в одной строке, мы используем метод r.iter_content для загрузки данных по частям с указанием размера фрагмента.
  •  r = requests.get (URL, поток = True) 

    Установка параметра stream на True приведет к загрузке только заголовков ответов, а соединение останется открытым.Это позволяет избежать считывания всего содержимого сразу в память для больших ответов. Фиксированный фрагмент будет загружаться каждый раз, пока выполняется итерация r.iter_content .

    Вот пример:

    импорт запросов

    r = requests.get (file_url, stream = True )

    с открытым ( "питон.pdf " , " wb " ) как pdf:

    для фрагмента в r.iter_content (chunk_size = 1024 ):

    если фрагмент:

    pdf.write (кусок)

    Загрузка видео

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

    импорт запросов

    из BS4 импорт BeautifulSoup

    def get_video_links ():

    r = запросов.получить (archive_url)

    суп = BeautifulSoup (r.content, 'html5lib' )

    ссылок = soup.findAll ( 'a' )

    video_links = [archive_url + ссылка [ 'href' ] для ссылка в ссылок если ссылка [ 'href ' ].заканчивается с ( 'mp4' )]

    возврат video_links

    def download_video_series (video_links):

    для ссылка в video_links:

    имя_файла = ссылка.сплит ( '/' ) [ - 1 ]

    печать ( "Загрузка файла:% s" % имя_файла)

    r = request.get (ссылка, поток = True )

    с открытым (имя_файла, 'wb' ) как f:

    для фрагмента дюйм r.iter_content (размер_груба = 1024 * 1024 ):

    если фрагмент:

    F. запись (фрагмент)

    печать ( "% s загружено! \ N" % имя_файла)

    распечатать ( «Все видео загружены!» )

    возврат

    , если __name__ = = "__main__" :

    video_links = get_video_links ()

    download_video_series (video_links)

    Преимущества использования библиотеки запросов для загрузки веб-файлов:

    Этот блог предоставил Нихил Кумар.Если вам нравится GeeksforGeeks, и вы хотели бы внести свой вклад, вы также можете написать статью с помощью provide.geeksforgeeks.org или отправить ее по электронной почте на [email protected] Смотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогайте другим гикам.

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

    Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

    Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS .


    Глава 8 - Работа с файлами - документация Python 101 1.0

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

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

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

     Это тестовый файл
    строка 2
    строка 3
    эта строка намеренно оставлена ​​пустой
     

    Вот несколько примеров, показывающих, как использовать open для чтения:

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

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

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

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

    Как видите, когда мы не указываем его как необработанную строку, мы получаем недопустимый путь. Почему так происходит? Что ж, как вы, возможно, помните из главы, посвященной строкам, есть определенные специальные символы, которые нужно экранировать, например, «n» или «t». В этом случае мы видим букву «t» (т. Е. Табуляцию), поэтому строка послушно добавляет табуляцию к нашему пути и запирает его за нас.

    Второй аргумент во втором примере также является буквой «r». Это сообщает open , что мы хотим открыть файл в режиме только для чтения. Другими словами, он делает то же самое, что и первый пример, но более явный. А теперь давайте прочтем файл!

    Поместите следующие строки в сценарий Python и сохраните его в том же месте, что и файл test.txt:

     handle = open ("test.txt", "r")
    data = handle.read ()
    печать (данные)
    handle.close ()
     

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

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

     handle = open ("test.txt", "r")
    data = handle.readline () # читать только одну строку
    печать (данные)
    handle.close ()
     

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

     handle = open ("test.txt", "r")
    data = handle.readlines () # читать ВСЕ строки!
    печать (данные)
    handle.close ()
     

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

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

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

     handle = open ("test.txt", "r")
    
    для линии в ручке:
        печать (строка)
    
    handle.close ()
     

    Здесь мы открываем дескриптор файла, доступный только для чтения, а затем используем цикл для , чтобы перебрать его.Вы обнаружите, что можете перебирать все виды объектов в Python (строки, списки, кортежи, ключи в словаре и т. Д.). Это было довольно просто, правда? А теперь давайте разберемся по частям!

     handle = open ("test.txt", "r")
    
    в то время как True:
        data = handle.read (1024)
        печать (данные)
        если не данные:
            сломать
     

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

    Как читать двоичный файл

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

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

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

    Написание файлов на Python

    Если вы следовали инструкциям, вы, вероятно, можете догадаться, что означает флаг файлового режима для записи файлов: «w» и «wb» для режима записи и двоичного режима записи.Давайте посмотрим на простой пример, не так ли?

    ВНИМАНИЕ : При использовании режимов «w» или «wb», если файл уже существует, он будет перезаписан без предупреждения! Вы можете проверить, существует ли файл, прежде чем открывать его, используя модуль Python os . См. Раздел os.path.exists в Глава 16 .

     handle = open ("test.txt", "w")
    handle.write («Это тест!»)
    handle.close ()
     

    Это было легко! Все, что мы здесь сделали, это изменили режим файла на «w» и вызвали метод write дескриптора файла, чтобы записать текст в файл.У дескриптора файла также есть метод Writelines , который принимает список строк, которые дескриптор затем будет записывать на диск по порядку.

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

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

     с открытым ("тест.txt ") как file_handler:
        для строки в file_handler:
            печать (строка)
     

    Синтаксис оператора с оператором немного странный, но вы быстро его поймете. В основном мы заменяем:

     handle = open ("test.txt")
     

    с этим:

     с open ("test.txt") в качестве file_handler:
     

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

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

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

     попробуйте:
        file_handler = open ("test.txt")
        для строки в file_handler:
            печать (строка)
    кроме IOError:
        print («Произошла ошибка ввода-вывода!»)
    Ну наконец то:
        file_handler.close ()
     

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

    .
     попробуйте:
        с open ("test.txt") в качестве file_handler:
            для строки в file_handler:
                печать (строка)
    кроме IOError:
        print («Произошла ошибка ввода-вывода!»)
     

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

    Заключение

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

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

    Это руководство написано с использованием Python 3.6

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

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

    Рекурсивный просмотр каталогов

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

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

      ## Это будет проходить через КАЖДЫЙ файл на вашем компьютере
    импорт ОС
    
    ## Вы можете изменить "/" на каталог по вашему выбору
    для файла в os.walk ("/"):
        распечатать файл)
      

    Выход

    Давайте посмотрим, как это работает в каталоге, в котором есть 3 разных файла: ['test2.txt, 'test.txt', 'main.py']

      >>> импорт ОС
    >>> os.walk ("./")
    <обход объекта генератора на 0x10457c7d8>
    >>> для файла в os.walk ("./"):
    ...     распечатать файл)
    ...
    ('./', [], ['test2.txt', 'test.txt', 'main.py'])
      

    Проверка файла или каталога?

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

    Для этого мы можем использовать функцию os.path.isfile () , которая возвращает False , если это каталог или True , если это действительно файл.

      >>> импорт ОС
    >>> os.path.isfile ("/")
    Ложь
    >>> os.path.isfile ("./ main.py")
    Правда
      

    Проверка существования файла или каталога

    Если вы хотите проверить, существует ли что-то на вашем текущем компьютере, вы можете используйте функцию os.path.exists () , передав файл или каталог, который вы хотите для проверки:

      >>> импорт ОС
    >>> os.path.exists ("./ main.py")
    Правда
    >>> os.path.exists ("./ dud.py")
    Ложь
      

    Создание каталогов в Python

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

     , если не os.path.exists ('my_dir'):
        os.makedirs ('my_dir')
      

    Сначала мы проверим, существует ли каталог my_dir , если его не существует, тогда он пойдет дальше и вызовет os.makedirs ('my_dir') в чтобы создать для нас наш новый каталог.

    Следует отметить, что это потенциально могло вызвать проблемы. Если бы вы были создайте каталог после проверки, что каталог где-то не существует иначе, перед вашим вызовом os.makedirs ('my_dir') вы могли бы увидеть OS Ошибка выброшено.

    Однако по большей части у вас все будет в порядке, используя метод, упомянутый выше. Если вы хотите быть особенно осторожными и улавливать любые возможные исключения, тогда вы можете wrap вы звоните на os.makedirs ('my_dir') в попытке ... кроме , например:

     , если не os.path.exists ('my_dir'):
        пытаться:
            os.makedirs ('my_dir')
        кроме OSError как e:
            если e.errno! = errno.EEXIST:
                поднять
      

    Заключение

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


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

    Я предпочитаю работать с Python, потому что это очень гибкий язык программирования, который позволяет мне легко взаимодействовать с операционной системой.Это также включает функции файловой системы. Чтобы просто перечислить файлы в каталоге, в игру вступают модули os , subprocess , fnmatch и pathlib . Следующие ниже решения демонстрируют, как эффективно использовать эти методы.

    Использование os.walk ()

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

    os.walk () возвращает список из трех элементов. Он содержит имя корневого каталога, список имен подкаталогов и список имен файлов в текущем каталоге. В листинге 1 показано, как написать это с помощью всего трех строк кода. Это работает с интерпретаторами Python 2 и 3.

    Листинг 1: Обход текущего каталога с помощью os.walk ()

      импорт ОС
    
    для root, dirs, файлов в os.ходить("."):
        для имени файла в файлах:
            печать (имя файла)
      

    Использование командной строки через подпроцесс

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

    Как уже было описано в статье Параллельная обработка в Python, модуль подпроцесса позволяет выполнить системную команду и собрать ее результат. Системная команда, которую мы вызываем в этом случае, следующая:

    Пример 1: Список файлов в текущем каталоге

      $ ls -p.| grep -v / $
      

    Команда ls -p. перечисляет файлы каталогов для текущего каталога и добавляет разделитель / в конце имени каждого подкаталога, который нам понадобится на следующем шаге. Выходные данные этого вызова передаются команде grep , которая фильтрует данные по мере необходимости.

    Параметры -v / $ исключают все имена записей, заканчивающиеся разделителем /. Фактически, / - это регулярное выражение, которое соответствует всем строкам, которые содержат символ / в качестве самого последнего символа перед концом строки, который представлен как /.

    Модуль подпроцесса позволяет создавать реальные каналы и соединять потоки ввода и вывода, как вы это делаете в командной строке. Вызов метода subprocess.Popen () открывает соответствующий процесс и определяет два параметра с именами stdin и stdout .

    В листинге 2 показано, как это запрограммировать. Первая переменная ls определяется как процесс, выполняющий ls -p. , который выводится в канал. Вот почему канал stdout определен как подпроцесс .ТРУБКА . Вторая переменная grep также определяется как процесс, но вместо этого выполняет команду grep -v / $ .

    Для чтения вывода команды ls из конвейера канал stdin grep определяется как ls.stdout . Наконец, переменная endOfPipe считывает вывод grep из grep.stdout , который выводится на стандартный вывод поэлементно в цикле для ниже. Результат можно увидеть в примере 2 .

    Листинг 2: Определение двух процессов, связанных с конвейером

      импорт подпроцесса
    
    # определяем команду ls
    ls = subprocess.Popen (["ls", "-p", "."],
                          stdout = subprocess.PIPE,
                         )
    
    # определяем команду grep
    grep = subprocess.Popen (["grep", "-v", "/ $"],
                            stdin = ls.stdout,
                            stdout = subprocess.PIPE,
                            )
    
    # читать с конца канала (stdout)
    endOfPipe = grep.стандартный вывод
    
    # выводим файлы построчно
    для строки в endOfPipe:
        печать (строка)
      

    Пример 2: Запуск программы

      $ python find-files3.py
    find-files2.py
    find-files3.py
    find-files4.py
    ...
      

    Это решение хорошо работает как с Python 2, так и с Python 3, но можем ли мы как-то его улучшить? Тогда давайте посмотрим на другие варианты.

    Объединение os и fnmatch

    Как вы видели ранее, решение, использующее подпроцессы, элегантно, но требует большого количества кода.Вместо этого давайте объединим методы из двух модулей os и fnmatch . Этот вариант работает также с Python 2 и 3.

    В качестве первого шага мы импортируем два модуля os и fnmatch . Затем мы определяем каталог, в котором мы хотели бы перечислить файлы, используя os.listdir () , а также шаблон для фильтрации файлов. В цикле для мы перебираем список записей, хранящихся в переменной listOfFiles .

    Наконец, с помощью fnmatch мы фильтруем записи, которые ищем, и выводим соответствующие записи в стандартный вывод. Листинг 3 содержит скрипт Python, а Пример 3 соответствующий вывод.

    Листинг 3: Список файлов с использованием модуля os и fnmatch

      импорт ОС, fnmatch
    
    listOfFiles = os.listdir ('.')
    pattern = "* .py"
    для записи в listOfFiles:
        если fnmatch.fnmatch (запись, шаблон):
                печать (запись)
      

    Пример 3: Результат Листинга 3

      $ python2 find-files.ру
    find-files.py
    find-files2.py
    find-files3.py
    ...
      

    Использование os.listdir () и генераторов

    Проще говоря, генератор - это мощный итератор, который сохраняет свое состояние. Чтобы узнать больше о генераторах, ознакомьтесь с одной из наших предыдущих статей, Генераторы Python.

    Следующий вариант объединяет метод listdir () модуля os с функцией генератора. Код работает с обеими версиями Python 2 и 3.

    Работа с PDF-файлами в Python: чтение и разделение страниц

    Эта статья является первой из серии, посвященной работе с PDF-файлами на Python:

    Формат документа PDF

    Сегодня Portable Document Format (PDF) относится к наиболее часто используемым форматам данных.В 1990 году структура документа PDF была определена компанией Adobe. Идея формата PDF заключается в том, что передаваемые данные / документы выглядят одинаково для обеих сторон, участвующих в процессе коммуникации - создателя, автора или отправителя и получателя. PDF является преемником формата PostScript и стандартизирован как ISO 32000-2: 2017.

    Обработка PDF-документов

    Для Linux доступны мощные инструменты командной строки, такие как pdftk и pdfgrep. Как разработчик испытывает огромное волнение при создании собственного программного обеспечения, основанного на Python и использующего библиотеки PDF, которые находятся в свободном доступе.

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

    Инструменты и библиотеки

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

    • PyPDF2: библиотека Python для извлечения информации и содержимого документа, разделения документов по страницам, объединения документов, обрезки страниц и добавления водяных знаков. PyPDF2 поддерживает как незашифрованные, так и зашифрованные документы.

    • PDFMiner: полностью написан на Python и хорошо работает с Python 2.4. Для Python 3 используйте клонированный пакет PDFMiner.six. Оба пакета позволяют анализировать, анализировать и конвертировать PDF-документы. Это включает поддержку PDF 1.7, а также языков CJK (китайский, японский и корейский) и различных типов шрифтов (Type1, TrueType, Type3 и CID).

    • PDFQuery: Он описывает себя как «быструю и удобную библиотеку для парсинга PDF», которая реализована как оболочка для PDFMiner, lxml и pyquery.Его цель дизайна - «надежно извлекать данные из наборов PDF-файлов с минимальным количеством кода».

    • tabula-py: это простая оболочка Python для tabula-java, которая может читать таблицы из PDF-файлов и преобразовывать их в Pandas DataFrames. Он также позволяет конвертировать файл PDF в файл CSV / TSV / JSON.

    • pdflib для Python: расширение библиотеки Poppler, которое предлагает для него привязки Python. Он позволяет анализировать, анализировать и конвертировать PDF-документы.Не путать с его коммерческим кулоном с таким же названием.

    • PyFPDF: библиотека для создания PDF-документов на Python. Портировано из библиотеки FPDF PHP, хорошо известного замены расширения PDFlib с множеством примеров, скриптов и производных.

    • PDFTables: коммерческий сервис, предлагающий извлечение из таблиц в виде PDF-документа. Предлагает API, позволяющий использовать PDFTables в качестве SAAS.

    • PyX - графический пакет Python: PyX - это пакет Python для создания файлов PostScript, PDF и SVG.Он сочетает в себе абстракцию модели рисования PostScript с интерфейсом TeX / LaTeX. На основе этих примитивов строятся сложные задачи, такие как создание 2D и 3D графиков в готовом для публикации качестве.

    shutil - высокоуровневые файловые операции - документация Python 3.9.1

    Исходный код: Lib / shutil.py


    Модуль shutil предлагает ряд высокоуровневых операций с файлами и коллекции файлов.В частности, предусмотрены функции, поддерживающие файл копирование и удаление. Для операций с отдельными файлами см. Также os модуль.

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

    Даже функции копирования файлов более высокого уровня ( shutil.copy () , shutil.copy2 () ) не может скопировать все метаданные файла.

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

    Операции с каталогами и файлами

    шутиль. copyfileobj ( fsrc , fdst [, длина ])

    Скопируйте содержимое файлового объекта fsrc в файловый объект fdst . Целое число , длина , если задано, является размером буфера. В частности, отрицательный Длина Значение означает копирование данных без зацикливания на исходных данных в куски; по умолчанию данные читаются по частям, чтобы избежать неконтролируемой памяти потребление.Обратите внимание, что если текущая позиция файла объекта fsrc не 0, только содержимое от текущей позиции файла до конца файла будет скопировать.

    шутиль. файл копии ( src , dst , * , follow_symlinks = True )

    Скопируйте содержимое (без метаданных) файла с именем src в файл с именем dst и вернуть dst наиболее эффективным способом. src и dst - это объекты, похожие на пути, или имена путей, заданные в виде строк.

    dst должно быть полным именем целевого файла; посмотрите на копия () для копии, которая принимает путь к целевому каталогу. Если src и dst укажите тот же файл, SameFileError возбуждается.

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

    Если follow_symlinks является ложным и src является символической ссылкой, будет создана новая символическая ссылка вместо копирования file src указывает на.

    Вызывает событие аудита shutil.copyfile с аргументами src , dst .

    Изменено в версии 3.3: раньше вызывалось IOError вместо OSError .Добавлен аргумент follow_symlinks . Теперь возвращает dst .

    Изменено в версии 3.4: Поднять SameFileError вместо Error . Поскольку первый подкласс последнего, это изменение обратно совместимо.

    исключение shutil. SameFileError

    Это исключение возникает, если источник и место назначения в copyfile () это один и тот же файл.

    шутиль. copymode ( src , dst , * , follow_symlinks = True )

    Скопируйте биты разрешений из src в dst . Содержимое файла, владелец и группы не затронуты. src и dst - это объекты, похожие на пути, или имена путей даны в виде строк. Если follow_symlinks ложно, а src и dst являются символическими ссылками, copymode () попытается изменить режим самого dst (скорее чем файл, на который он указывает).Эта функция доступна не на всех Платформа; см. copystat () для получения дополнительной информации. Если copymode () не может изменять символические ссылки на локальной платформе, и это просят сделать это, он ничего не сделает и вернется.

    Вызывает событие аудита shutil.copymode с аргументами src , dst .

    Изменено в версии 3.3: Добавлен аргумент follow_symlinks .

    шутиль. copystat ( src , dst , * , follow_symlinks = True )

    Скопируйте биты разрешений, время последнего доступа, время последнего изменения и флаги от src до dst . В Linux copystat () также копирует «Расширенные атрибуты», где это возможно. Содержимое файла, владелец и группы не затронуты. src и dst - это объекты, подобные пути или пути имена даны в виде строк.

    Если follow_symlinks ложно, а src и dst оба обратитесь к символическим ссылкам, copystat () будет работать с сами символические ссылки, а не файлы, символические ссылки относятся к - чтение информации из src символическая ссылка и запись информации в dst символическая ссылка.

    Примечание

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

    • Если os.chmod в os.supports_follow_symlinks - это True , copystat () может изменять разрешение биты символической ссылки.

    • Если os.utime в os.supports_follow_symlinks равно True , copystat () может изменять последний доступ и время модификации символической ссылки.

    • Если os.chflags в os.supports_follow_symlinks - это True , copystat () может изменять флаги символическая ссылка.

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

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

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