В этом и последующих уроках мы подробно разберем работу с файлами при помощи встроенных средств Python. Научимся правильно открывать, закрывать файлы, а так же читать и записывать в них.
Открытие файла
Для начала создадим файл с любым именем, например, file.txt в папке с проектом и откроем его при помощи Python в режиме чтения. Для открытия файла в Python существует функция open() :
f = open(‘file.txt’, ‘r’)
В нашем примере функция open() принимает два аргумента: путь до файла и режим, в котором открывается файл. Можно так же явно указать, что второй аргумент является именно режимом:
f = open(‘file.txt’, mode=’r’)
Пока не будем вдаваться в подробности использования второго примера, вместо первого. Вернемся к этому вопросу в подразделе «Кодировка».
Аргумент r означает, что файл будет открыт только в режиме чтения. Далее представлены возможные режимы:
- r – открытие файла для чтение (используется по умолчанию);
- w – открытие файла для записи, при этом все содержимое файла удаляется, а в случае отсутствия файла по указанному пути, он создается;
- x – создание нового файла для записи (если файл уже существовал, то возникнет исключение);
- a – открытие файла для записи, при этом содержимое не удаляется, а новая информация добавляется в конец файла;
- b – открытие файла в бинарном режиме;
- t – открытие файла в текстовом режиме (используется по умолчанию);
- + — открытие файла для чтения и записи.
Перечисленные выше режимы открытия файла можно комбинировать. По умолчанию файл открывается в режиме чтения текста, то есть пример открытия файла в режиме чтения можно было написать проще:
Что такое Python и почему вы захотите его изучить?
f = open(‘file.txt’)
Отлично, мы открыли файл. Теперь необходимо его прочитать и, например, вывести в консоль. Функция open() возвращает объект класса _io.TextIOWrapper :
f = open(‘file.txt’)
print(type(f)) # =>
Объект класса _io.TextIOWrapper имеет атрибуты name , mode и closed , возвращающие имя файла, режим, в котором он открыт и закрыт ли он, соответственно.
f = open(‘file.txt’)
print(f.name) # => file.txt
print(f.mode) # => r
print(f.closed) # => False
f.close() # закрываем файл
print(f.closed) # => True
Пока мы не изучали ООП (но скоро дойдем до этой темы), поэтому определение атрибутов постараюсь объяснить на примере. Предположим, у нас есть автомобиль (это класс). Автомобилей может быть бесконечное множество: грузовые, легковые и так далее, это объекты. Все автомобили имеют атрибуты: марка, масса, цвет и так далее, это атрибуты класса. Так же все автомобили выполняют какие-то функции: ехать вперед, поворачивать и так далее, это методы класса.
Путь до файла в Python
Мы открыли файл, который расположен в той же директории, что и файл с программой. Такое случается далеко не всегда. В этом подразделе разберемся более подробно с путем до файла в Python.
Чтобы получить абсолютный путь до файла, необходимо подключить библиотеку os . В классе path есть метод abspath() , который возвращает абсолютный путь до файла указанного в аргументе:
Что такое Python/Питон?
import os
print(os.path.abspath(‘file.txt’)) # => C:UsersUserfile.txt
Теперь мы можем открыть файл, используя абсолютный путь (только необходимо заменить слеши на / ):
f = open(‘C:/Users/User/file.txt’)
Или использовать спецификатор r , который указывает на использование строки в «сыром» виде (нечто похожее мы встречали в уроке 2.4.):
f = open(r’C:UsersUserfile.txt’)
С абсолютными путями разобрались, но как открыть файл, если он расположен в папке на уровень выше или ниже. Если на одном уровне с файлом программы расположена папка, например, folder и необходимый файл находится в ней, то, чтобы открыть файл, следует использовать такой относительный путь:
f = open(‘folder/file.txt’)
Если файл находится выше на одну директорию, то необходимо использовать обозначение « ../ »:
f = open(‘../file.txt’)
Если на два директории выше, то:
f = open(‘../../file.txt’)
Чтение из файла
Теперь от атрибутов перейдем к методам, а именно, методу чтения файла read() , возвращающего объект строкового типа:
f = open(‘file.txt’)
data = f.read()
print(data)
Метод read() без параметров возвращает содержимое всего файла. Если в параметре написать целочисленное число, то будет возвращено указанное количество символов:
f = open(‘file.txt’)
data = f.read(2)
print(data)
На самом деле, прочитать информацию построчно можно и без метода read() , а только с использованием цикл for.
f = open(‘file.txt’)
for line in f:
print(line)
Обратите внимание на то, что между строками есть пустая. Откуда она берется? В переменную line сохраняется строка целиком, вместе с символом переноса строки n . Второй перенос добавляется функция print() . Можем это исправить:
f = open(‘file.txt’)
for line in f:
print(line, end=»)
В следующем уроке узнаем об еще более удобном и надежном способе чтения данных из файла.
Итак, вы открыли файл и прочитали необходимые данные. Теперь необходимо его корректно закрыть. Для этого существует метод close() .
f.close()
Может возникнуть вопрос, почему разработчики языка сделали close() методом, а не функцией, как open() . Предположим, что open() являлся бы методом:
‘file.txt’.open()
В таком случае потребовалось бы, чтобы строковый тип содержал методы для открытия файла и других дополнений для строкового типа. Функция open() создает новый объект для работы с ним, такая реализация намного проще:
open(‘file.txt’)
Тогда почему close() является методом, а не функцией, например:
close(f) # f – объект, который был создан функцией open()
Такой способ был бы то же неэффективным, так как в функцию пришлось бы передавать целый объект. Так как каждый созданный функцией open() объект имеет свои атрибуты и поля, намного проще и лучше, чтобы экземпляр имел метод close() .
f = open(‘file.txt’) # открыли файл
f.close() # закрыли файл
Запись в файл
Читать из файла научились. Теперь попробуем записать в файл при помощи встроенных средств Python. Инициализируем переменную str строкой « Hello, World », откроем файл и запишем ее в него при помощи метода write() :
str = «Hello, World»
f = open(‘file.txt’)
f.write(str)
Программа не запустилась. Все правильно, мы же открыли файл для чтения (так как не указали параметр mode ). Исправим это и откроем файл в режиме с записью в конец файла:
str = «Hello, World»
f = open(‘file.txt’, ‘a’)
f.write(str)
Запустите пару раз программу и посмотрите содержимое файла file.txt . Кстати, метод write() возвращает количество записанных символов:
str = «Hello, World»
f = open(‘file.txt’, ‘a’)
print(f.write(str)) # => 12
Теперь напишите текст на кириллице, запустите программу и посмотрите результат в файле file.txt :
str = «Привет»
f = open(‘file.txt’, ‘a’)
f.write(str)
Какие-то кракозябры? Разберемся в следующем разделе.
Кодировка файла в Python
Вернемся к функции open() , которая открывает файл. Если заглянуть в модуль встроенных функций builtins.py и найти там функцию open() , можно увидеть какие параметры принимает эта функция (с первыми двумя мы уже разобрались):
def open(file, mode=’r’, buffering=None, encoding=None, errors=None, newline=None, closefd=True)
Чтобы открыть файл в нужной кодировке есть параметр encoding . Теперь откроем наш файл в кодировке UTF-8:
str = «Привет»
f = open(‘file.txt’, ‘a’, ‘utf-8’)
f.write(str)
Снова ошибка. Третьим параметром является buffering , в который мы передали аргумент utf-8 . Чтобы это исправить, следует явно указать параметр, в который мы передаем аргумент:
str = «Привет»
f = open(‘file.txt’, ‘a’, encoding=’utf-8′)
f.write(str)
Если мы явно указываем параметр, то их порядок не важен:
str = «Привет»
f = open(‘file.txt’, encoding=’utf-8′, mode=’a’)
f.write(str)
После окончания работы с файлом, необходимо его закрыть с помощью метода close() :
…
f.write(str)
f.close()
Об аргументах и параметрах мы еще будем говорить в теме «Функции».
В этом уроке разобрались, как открывать файлы в разных режимах в Python, познакомились с абсолютными и относительными путями, научились читать из файла и записывать в него.
В следующем уроке познакомимся с более современным и надежным способом открытия файла, при помощи конструкции with/as , которая гарантирует закрытие файла в любом случае.
Источник: codebra.ru
Осваиваем Python 3 — работа с файлами
В этой статье мы рассмотрим операции с файлами в Python. Открытие файла Python. Чтение из файла Python. Запись в файл Python, закрытие файла. А также методы, предназначенные для работы с файлами.
Работа с файлами питон — что такое файл Python?
Файл – это именованная область диска, предназначенная для длительного хранения данных в постоянной памяти (например, на жёстком диске).
Чтобы прочитать или записать данные в файл, сначала нужно его открыть. После окончания работы файл необходимо закрыть, чтобы освободить связанные с ним ресурсы.
Поэтому в Python операции с файлами выполняются в следующем порядке:
- Открытие файла Python.
- Чтение из файла Python или запись в файл Python (выполнение операции).
- Закрытие файла Python.
Открытие файла Python
Не знаете как открыть файл в питоне? В Python есть встроенная функция open(), предназначенная для открытия файла. Она возвращает объект, который используется для чтения или изменения файла.
>>> f = open(«test.txt») # открыть файл в текущей папке >>> f = open(«C:/Python33/README.txt») # указание полного пути
При этом можно указать необходимый режим открытия файла: ‘r’- для чтения,’w’ — для записи,’a’ — для изменения. Мы также можем указать, хотим ли открыть файл в текстовом или в бинарном формате.
По умолчанию файл открывается для чтения в текстовом режиме. При чтении файла в этом режиме мы получаем строки.
В бинарном формате мы получим байты. Этот режим используется для чтения не текстовых файлов, таких как изображения или exe-файлы.
| Открытие файла Python- возможные режимы | |
| Режим | Описание |
| ‘r’ | Открытие файла для чтения. Режим используется по умолчанию. |
| ‘w’ | Открытие файла для записи. Режим создаёт новый файл, если он не существует, или стирает содержимое существующего. |
| ‘x’ | Открытие файла для записи. Если файл существует, операция заканчивается неудачей (исключением). |
| ‘a’ | Открытие файла для добавления данных в конец файла без очистки его содержимого. Этот режим создаёт новый файл, если он не существует. |
| ‘t’ | Открытие файла в текстовом формате. Этот режим используется по умолчанию. |
| ‘b’ | Открытие файла в бинарном формате. |
| ‘+’ | Открытие файла для обновления (чтения и записи). |
f = open(«test.txt») # эквивалент ‘r’ или ‘rt’ f = open(«test.txt»,’w’) # запись в текстовом режиме f = open(«img.bmp»,’r+b’) # чтение и запись в бинарном формате
В отличие от других языков программирования, в Python символ ‘a’ не подразумевает число 97, если оно не закодировано в ASCII (или другой эквивалентной кодировке).
Кодировка по умолчанию зависит от платформы. В Windows – это ‘cp1252’, а в Linux ‘utf-8’.
Поэтому мы не должны полагаться на кодировку по умолчанию. При работе с файлами в текстовом формате рекомендуется указывать тип кодировки.
f = open(«test.txt»,mode = ‘r’,encoding = ‘utf-8’)
Как закрыть файл в Python?
Закрытие освободит ресурсы, которые были связаны с файлом. Это делается с помощью метода close(), встроенного в язык программирования Python.
В Python есть сборщик мусора, предназначенный для очистки ненужных объектов, Но нельзя полагаться на него при закрытии файлов.
f = open(«test.txt»,encoding = ‘utf-8’) # выполнение операций с файлом f.close()
Этот метод не полностью безопасен. Если при операции возникает исключение, выполнение будет прервано без закрытия файла.
Более безопасный способ – использование блока try. finally.
try: f = open(«test.txt»,encoding = ‘utf-8’) # выполнение операций с файлом finally: f.close()
Это гарантирует правильное закрытие файла даже после возникновения исключения, прерывающего выполнения программы.
Также для закрытия файла можно использовать конструкцию with. Оно гарантирует, что файл будет закрыт при выходе из блока with. При этом не нужно явно вызывать метод close(). Это будет сделано автоматически.
with open(«test.txt»,encoding = ‘utf-8’) as f: # выполнение операций с файлом
Запись в файл Python
Чтобы записать данные в файл в Python, нужно открыть его в режиме ‘w’, ‘a’ или ‘x’. Но будьте осторожны с режимом ‘w’. Он перезаписывает файл, если то уже существует.
Все данные в этом случае стираются.
Запись строки или последовательности байтов (для бинарных файлов) осуществляется методом write(). Он возвращает количество символов, записанных в файл.
with open(«test.txt»,’w’,encoding = ‘utf-8’) as f: f.write(«my first filen») f.write(«This filenn») f.write(«contains three linesn»)
Эта программа создаст новый файл ‘test.txt’. Если он существует, данные файла будут перезаписаны. При этом нужно добавлять символы новой строки самостоятельно, чтобы разделять строки.
Чтение из файла Python
Чтобы осуществить чтение из файла Python, нужно открыть его в режиме чтения. Для этого можно использовать метод read(size), чтобы прочитать из файла данные в количестве, указанном в параметре size. Если параметр size не указан, метод читает и возвращает данные до конца файла.
>>> f = open(«test.txt»,’r’,encoding = ‘utf-8’) >>> f.read(4) # чтение первых 4 символов ‘This’ >>> f.read(4) # чтение следующих 4 символов ‘ is ‘ >>> f.read() # чтение остальных данных до конца файла ‘my first filenThis filencontains three linesn’ >>> f.read() # дальнейшие попытки чтения возвращают пустую строку »
Метод read() возвращает новые строки как ‘n’. Когда будет достигнут конец файла, при дальнейших попытках чтения мы получим пустые строки.
Чтобы изменить позицию курсора в текущем файле, используется метод seek(). Метод tell() возвращает текущую позицию курсора (в виде количества байтов).
>>> f.tell() # получаем текущую позицию курсора в файле 56 >>> f.seek(0) # возвращаем курсор в начальную позицию 0 >>> print(f.read()) # читаем весь файл This is my first file This file contains three lines
Мы можем прочитать файл построчно в цикле for.
>>> for line in f: . print(line, end = ») . This is my first file This file contains three lines
Извлекаемые из файла строки включают в себя символ новой строки ‘n’. Чтобы избежать вывода, используем пустой параметр end метода print(),.
Также можно использовать метод readline(), чтобы извлекать отдельные строки. Он читает файл до символа новой строки.
>>> f.readline() ‘This is my first filen’ >>> f.readline() ‘This filen’ >>> f.readline() ‘contains three linesn’ >>> f.readline() »
Метод readlines() возвращает список оставшихся строк. Все эти методы чтения возвращают пустую строку, когда достигается конец файла.
>>> f.readlines() [‘This is my first filen’, ‘This filen’, ‘contains three linesn’]
Python работа с файлами — основные методы
Ниже приводится полный список методов для работы с файлами в текстовом режиме.
| Python работа с файлами — методы | |
| Метод | Описание |
| close() | Закрытие файла. Не делает ничего, если файл закрыт. |
| detach() | Отделяет бинарный буфер от TextIOBase и возвращает его. |
| fileno() | Возвращает целочисленный дескриптор файла. |
| flush() | Вызывает сброс данных (запись на диск) из буфера записи файлового потока. |
| isatty() | Возвращает значение True, если файловый поток интерактивный. |
| read(n) | Читает максимум n символов из файла. Читает до конца файла, если значение отрицательное или None. |
| readable() | Возвращает значение True, если из файлового потока можно осуществить чтение. |
| readline(n=-1) | Читает и возвращает одну строку из файла. Читает максимум n байт, если указано соответствующее значение. |
| readlines(n=-1) | Читает и возвращает список строк из файла. Читает максимум n байт/символов, если указано соответствующее значение. |
| seek(offset,from=SEEK_SET) | Изменяет позицию курсора. |
| seekable() | Возвращает значение True, если файловый поток поддерживает случайный доступ. |
| tell() | Возвращает текущую позицию курсора в файле. |
| truncate(size=None) | Изменяет размер файлового потока до size байт. Если значение size не указано, размер изменяется до текущего положения курсора. |
| writable() | Возвращает значение True, если в файловый поток может производиться запись. |
| write(s) | Записывает строки s в файл и возвращает количество записанных символов. |
| writelines(lines) | Записывает список строк lines в файл. |
Источник: www.internet-technologies.ru
Файлы в python, ввод-вывод
Эта статья посвящена работе с файлами (вводу/выводу) в Python: открытие, чтение, запись, закрытие и другие операции.
Файлы Python
Файл — это всего лишь набор данных, сохраненный в виде последовательности битов на компьютере. Информация хранится в куче данных (структура данных) и имеет название «имя файла» (filename).
В Python существует два типа файлов:
Текстовые файлы
Это файлы с человекочитаемым содержимым. В них хранятся последовательности символов, которые понимает человек. Блокнот и другие стандартные редакторы умеют читать и редактировать этот тип файлов.
Текст может храниться в двух форматах: ( .txt ) — простой текст и ( .rtf ) — «формат обогащенного текста».
Бинарные файлы
В бинарных файлах данные отображаются в закодированной форме (с использованием только нулей (0) и единиц (1) вместо простых символов). В большинстве случаев это просто последовательности битов.
Они хранятся в формате .bin .
Любую операцию с файлом можно разбить на три крупных этапа:
- Открытие файла
- Выполнение операции (запись, чтение)
- Закрытие файла
Открытие файла
Метод open()
В Python есть встроенная функция open() . С ее помощью можно открыть любой файл на компьютере. Технически Python создает на его основе объект.
f = open(file_name, access_mode)
- file_name = имя открываемого файла
- access_mode = режим открытия файла. Он может быть: для чтения, записи и т. д. По умолчанию используется режим чтения ( r ), если другое не указано. Далее полный список режимов открытия файла
Пример
Создадим текстовый файл example.txt и сохраним его в рабочей директории.
Следующий код используется для его открытия.
f = open(‘example.txt’,’r’) # открыть файл из рабочей директории в режиме чтения fp = open(‘C:/xyz.txt’,’r’) # открыть файл из любого каталога
В этом примере f — переменная-указатель на файл example.txt .
Следующий код используется для вывода содержимого файла и информации о нем.
>>> print(*f) # выводим содержимое файла This is a text file. >>> print(f) # выводим объект _io.TextIOWrapper name=’example.txt’ mode=’r’ encoding=’cp1252′>
Стоит обратить внимание, что в Windows стандартной кодировкой является cp1252 , а в Linux — utf-08 .
Закрытие файла
Метод close()
После открытия файла в Python его нужно закрыть. Таким образом освобождаются ресурсы и убирается мусор. Python автоматически закрывает файл, когда объект присваивается другому файлу.
Существуют следующие способы:
Способ №1
Проще всего после открытия файла закрыть его, используя метод close() .
f = open(‘example.txt’,’r’) # работа с файлом f.close()
После закрытия этот файл нельзя будет использовать до тех пор, пока заново его не открыть.
Способ №2
Также можно написать try/finally , которое гарантирует, что если после открытия файла операции с ним приводят к исключениям, он закроется автоматически.
Без него программа завершается некорректно.
Вот как сделать это исключение:
f = open(‘example.txt’,’r’) try: # работа с файлом finally: f.close()
Файл нужно открыть до инструкции try , потому что если инструкция open сама по себе вызовет ошибку, то файл не будет открываться для последующего закрытия.
Этот метод гарантирует, что если операции над файлом вызовут исключения, то он закроется до того как программа остановится.
Способ №3
Инструкция with
Еще один подход — использовать инструкцию with , которая упрощает обработку исключений с помощью инкапсуляции начальных операций, а также задач по закрытию и очистке.
В таком случае инструкция close не нужна, потому что with автоматически закроет файл.
Вот как это реализовать в коде.
with open(‘example.txt’) as f: # работа с файлом
Чтение и запись файлов в Python
В Python файлы можно читать или записывать информацию в них с помощью соответствующих режимов.
Функция read()
Функция read() используется для чтения содержимого файла после открытия его в режиме чтения ( r ).
Синтаксис
file.read(size)
- file = объект файла
- size = количество символов, которые нужно прочитать. Если не указать, то файл прочитается целиком.
Пример
>>> f = open(‘example.txt’,’r’) >>> f.read(7) # чтение 7 символов из example.txt ‘This is ‘
Интерпретатор прочитал 7 символов файла и если снова использовать функцию read() , то чтение начнется с 8-го символа.
>>> f.read(7) # чтение следующих 7 символов ‘ a text’
Функция readline()
Функция readline() используется для построчного чтения содержимого файла. Она используется для крупных файлов. С ее помощью можно получать доступ к любой строке в любой момент.
Пример
Создадим файл test.txt с нескольким строками:
This is line1. This is line2. This is line3.
Посмотрим, как функция readline() работает в test.txt .
>>> x = open(‘test.txt’,’r’) >>> x.readline() # прочитать первую строку This is line1. >>> x.readline(2) # прочитать вторую строку This is line2. >>> x.readlines() # прочитать все строки [‘This is line1.’,’This is line2.’,’This is line3.’]
Обратите внимание, как в последнем случае строки отделены друг от друга.
Функция write()
Функция write() используется для записи в файлы Python, открытые в режиме записи.
Если пытаться открыть файл, которого не существует, в этом режиме, тогда будет создан новый.
Синтаксис
file.write(string)
Пример
Предположим, файла xyz.txt не существует. Он будет создан при попытке открыть его в режиме чтения.
>>> f = open(‘xyz.txt’,’w’) # открытие в режиме записи >>> f.write(‘Hello n World’) # запись Hello World в файл Hello World >>> f.close() # закрытие файла
Переименование файлов в Python
Функция rename()
Функция rename() используется для переименовывания файлов в Python. Для ее использования сперва нужно импортировать модуль os.
import os os.rename(src,dest)
- src = файл, который нужно переименовать
- dest = новое имя файла
Пример
>>> import os >>> # переименование xyz.txt в abc.txt >>> os.rename(«xyz.txt»,»abc.txt»)
Текущая позиция в файлах Python
В Python возможно узнать текущую позицию в файле с помощью функции tell() . Таким же образом можно изменить текущую позицию командой seek() .
Пример
>>> f = open(‘example.txt’) # example.txt, который мы создали ранее >>> f.read(4) # давайте сначала перейдем к 4-й позиции This >>> f.tell() # возвращает текущую позицию 4 >>> f.seek(0,0) # вернем положение на 0 снова
Методы файла в Python
| file.close() | закрывает открытый файл |
| file.fileno() | возвращает целочисленный дескриптор файла |
| file.flush() | очищает внутренний буфер |
| file.isatty() | возвращает True, если файл привязан к терминалу |
| file.next() | возвращает следующую строку файла |
| file.read(n) | чтение первых n символов файла |
| file.readline() | читает одну строчку строки или файла |
| file.readlines() | читает и возвращает список всех строк в файле |
| file.seek(offset[,whene]) | устанавливает текущую позицию в файле |
| file.seekable() | проверяет, поддерживает ли файл случайный доступ. Возвращает True , если да |
| file.tell() | возвращает текущую позицию в файле |
| file.truncate(n) | уменьшает размер файл. Если n указала, то файл обрезается до n байт, если нет — до текущей позиции |
| file.write(str) | добавляет строку str в файл |
| file.writelines(sequence) | добавляет последовательность строк в файл |
Источник: pythonru.com
Различия между файлами .pyc, .pyd и .pyo в Python
В этой статье мы рассмотрим типы файлов Python .pyc, .pyo и .pyd, а также то, как они используются для хранения байт-кода, который будет импортирован другими программами.
Возможно, вы работали с файлами .py при написании кода Python, но вы хотите знать, что делают эти другие типы файлов и где они используются. Чтобы понять это, мы рассмотрим, как Python преобразует код, который вы пишете, в инструкции, которые машина может выполнять напрямую.
Байт-код и виртуальная машина
Python поставляется с интерпретатором, который можно использовать, как REPL (read-eval-print-loop) в интерактивном режиме в командной строке. В качестве альтернативы вы можете вызвать Python со сценариями кода Python.
В обоих случаях интерпретатор анализирует ваш ввод, а затем компилирует его в байт-код (машинные инструкции нижнего уровня), который затем выполняется «питоническим представлением» компьютера. Это представление Pythonic называется виртуальной машиной.
Однако он достаточно отличается от других виртуальных машин, таких как Java или Erlang, и заслуживает отдельного изучения. Виртуальная машина, в свою очередь, взаимодействует с операционной системой и реальным оборудованием для выполнения машинных инструкций.
Когда вы видите типы файлов .pyc, .pyo и .pyd, важно помнить, что это файлы, созданные интерпретатором Python при преобразовании кода в скомпилированный байт-код. Компиляция исходного кода Python в байт-код является необходимым промежуточным этапом в процессе преобразования инструкций из исходного кода на понятном человеку языке в машинные инструкции, которые может выполнять ваша операционная система.
В этой статье мы рассмотрим каждый тип файла по отдельности, но сначала мы кратко рассмотрим виртуальную машину и байт-код в Python.
Тип файла .pyc
Сначала рассмотрим тип файла .pyc, который автоматически генерируются интерпретатором при импорте модуля, что ускоряет импорт этого модуля в будущем. Следовательно, эти файлы создаются из файла .py только в том случае, если он импортируется другим файлом.
Вот пример модуля, который мы хотим импортировать. Этот модуль вычисляет факториалы.
# math_helpers.py # a function that computes the nth factorial, e.g. factorial(2) def factorial(n): if n == 0: return 1 else: return n * factorial(n — 1) # a main function that uses our factorial function defined above def main(): print(«I am the factorial helper») print(«you can call factorial(number) where number is any integer») print(«for example, calling factorial(5) gives the result:») print(factorial(5)) # this runs when the script is called from the command line if __name__ == ‘__main__’: main()
Теперь, когда вы просто запускаете этот модуль из командной строки, используя math_helpers.py, файлы .pyc не создаются.
Теперь давайте импортируем это в другой модуль, как показано ниже. Мы импортируем факториал из файла math_helpers.py и используем его для вычисления факториала 6.
# computations.py # import from the math_helpers module from math_helpers import factorial # a function that makes use of the imported function def main(): print(«Python can compute things easily from the REPL») print(«for example, just write : 4 * 5») print(«and you get: 20.») print(«Computing things is easier when you use helpers») print(«Here we use the factorial helper to find the factorial of 6») print(factorial(6)) # this runs when the script is called from the command line if __name__ == ‘__main__’: main()
Мы можем запустить этот скрипт, вызвав computations.py в терминале. Мы не только получаем результат 6 факториала, то есть 720, но мы также замечаем, что интерпретатор автоматически создает файл math_helpers.pyc. Это происходит потому, что модуль вычислений импортирует модуль math_helpers. Чтобы в дальнейшем ускорить загрузку импортированного модуля, интерпретатор создает файл байт-кода модуля.
При обновлении файла исходного кода обновляется и файл .pyc. Это происходит всякий раз, когда время обновления исходного кода отличается от времени обновления файла байт-кода и обеспечивает актуальность байт-кода.
Обратите внимание, что использование файлов .pyc только ускоряет загрузку вашей программы, но не ее фактическое выполнение. Это означает, что вы можете сократить время запуска, написав свою основную программу в модуле, который импортируется другим, меньшим модулем. Однако для повышения производительности в более общем плане вам необходимо изучить такие методы, как оптимизация алгоритмов и алгоритмический анализ.
Поскольку файлы .pyc не зависят от платформы, они могут использоваться на машинах с разной архитектурой. Однако, если разработчики имеют разное время в своих системах, проверка файлов .pyc в системе управления версиями может создать временные метки, которые фактически относятся к будущему для показаний времени других. Таким образом, обновления исходного кода больше не вызывают изменений в байт-коде. Это может быть неприятной ошибкой. Лучший способ избежать этого – добавить файлы .pyc в список игнорирования в вашей системе контроля версий.
Тип файла .pyo
Тип файла .pyo также создается интерпретатором при импорте модуля. Однако файл .pyo является результатом запуска интерпретатора при включенных настройках оптимизации.
Оптимизатор включается добавлением флага «-O» при вызове интерпретатора Python. Вот пример кода, иллюстрирующий использование оптимизации. Во-первых, у нас есть модуль, определяющий лямбда, которая похожа на функцию, но определяется более лаконично.
# lambdas.py # a lambda that returns double whatever number we pass it g = lambda x: x * 2
Если вы помните из предыдущего примера, нам нужно будет импортировать этот модуль, чтобы использовать его. В следующем листинге кода мы импортируем lambdas.py и используем лямбда g.
# using_lambdas.py # import the lambdas module import lambdas # a main function in which we compute the double of 7 def main(): print(lambdas.g(7)) # this executes when the module is invoked as a script at the command line if __name__ == ‘__main__’: main()
Теперь мы подошли к важной части этого примера. Вместо обычного вызова Python, как в последнем примере, мы воспользуемся здесь оптимизацией. При включенном оптимизаторе создаются файлы байт-кода меньшего размера, чем когда оптимизатор не используется.
Чтобы запустить этот пример с помощью оптимизатора, вызовите команду:
$ python -O using_lambdas.py
Мы не только получаем правильный результат удвоения 7, то есть 14, в качестве вывода в командной строке, но мы также видим, что для нас автоматически создается новый файл байт-кода. Этот файл основан на импорте lambdas.py при вызове using_lambdas.py. Поскольку у нас был включен оптимизатор, создается файл байт-кода .pyo. В данном случае он называется lambdas.pyo.
Оптимизатор, который мало что делает, удаляет утверждения assert из вашего байт-кода. Результат в большинстве случаев будет незаметен, но иногда он может понадобиться.
Также обратите внимание, что, поскольку создается файл байт-кода .pyo, он заменяет файл .pyc, который был бы создан без оптимизации. При обновлении файла исходного кода файл .pyo обновляется всякий раз, когда время обновления исходного кода отличается от времени обновления файла байт-кода.
Тип файла .pyd
Тип файла .pyd, в отличие от двух предыдущих, зависит от платформы для класса операционных систем Windows. Таким образом, его можно часто встретить в персональных и корпоративных выпусках Windows 10, 8, 7 и других.
В экосистеме Windows файл .pyd – это файл библиотеки, содержащий код Python, который может вызываться и использоваться другими приложениями. Чтобы сделать эту библиотеку доступной для других программ, она упакована в виде библиотеки динамической компоновки.
Библиотеки динамической компоновки (DLL) – это библиотеки кода Windows, которые связаны с вызывающими программами во время выполнения. Основное преимущество связывания с библиотеками во время выполнения, такими как библиотеки DLL, заключается в том, что это облегчает повторное использование кода, модульную архитектуру и более быстрый запуск программы. В результате библиотеки DLL предоставляют множество функций в операционных системах Windows.
Файл .pyd – это библиотека динамической компоновки, которая содержит модуль Python или набор модулей, которые будут вызываться другим кодом. Чтобы создать файл .pyd, вам необходимо создать модуль с именем, например, example.pyd. В этом модуле вам нужно будет создать функцию с именем PyInit_example(). Когда программы вызывают эту библиотеку, им нужно вызвать import foo, и функция PyInit_example() будет запущена.
Различия между этими типами файлов
Хотя между этими типами файлов существует некоторое сходство, есть также и некоторые большие различия. Например, хотя файлы .pyc и .pyo похожи тем, что содержат байт-код Python, они отличаются тем, что файлы .pyo более компактны благодаря оптимизации, выполненной интерпретатором.
Третий тип файла, .pyd, отличается от двух предыдущих тем, что представляет собой динамически подключаемую библиотеку, которая будет использоваться в операционной системе Windows. Два других типа файлов можно использовать в любой операционной системе, а не только в Windows.
Однако каждый из этих типов файлов включает код, который вызывается и используется другими программами Python.
В этой статье мы описали, как каждый специальный тип файла, .pyc, .pyo и .pyd, используется виртуальной машиной для повторного использования кода. Как мы видели, каждый файл имеет свои особые цели и варианты использования, будь то ускорение загрузки модуля, ускорение выполнения или облегчение повторного использования кода в определенных операционных системах.
Источник: tonais.ru
Работа с файлами
Взаимодействие с файлами в языке программирования Python предоставляет пользователю возможность хранить информацию, которая была обработана приложением, чтобы потом получать к ней доступ в любое удобное время. Базовые функции этого языка позволяют достаточно легко создавать, записывать и читать данные из файлов.
Создание и открытие
Чтобы получить возможность работать с файлом в Python 3, для начала его необходимо создать. Сделать это можно стандартными средствами операционной системы, перейдя в нужный каталог и создав новый документ с форматом txt. Однако аналогичное действие выполняется и с помощью метода open в языке программирования Python, которому надо передать в качестве параметров название файла и режим его обработки.
Следующий код демонстрирует получение переменной file ссылки на новый документ. Если запустить эту программу, она создаст текстовый файл test.txt в папке, где хранится исходный код.
file = open(«test.txt», «w») file.close()
Если же файл с указанным именем test.txt уже существует в каталоге с кодом, программа просто продолжит работу с ним, не создавая новый документ. Как можно заметить, имя файла является первым параметром метода open. Сразу за ним следует специальная буква, которая обозначает метод обработки данных. В данном случае «w» означает write, то есть запись.
Подробнее обо всех доступных режимах работы будет немного дальше, а сейчас важно усвоить, что после выполнения любых манипуляций над файлом, его обязательно следует закрыть с помощью функции close, чтобы гарантированно избежать потери информации.
В предыдущем примере для доступа к файлу был использован относительный путь, который не содержит в себе исчерпывающих сведений о местоположении объекта на жестком диске. Для того, чтобы задать их, необходимо в качестве первого аргумента функции open прописать абсолютный путь. В данном случае документ test.txt будет находиться в корневом каталоге на диске D, а не в папке программы.
file = open(r»D:test.txt», «w») file.close()
Перед строковым литералом мы использовали символ r, для отключения экранирования. Иначе компилятор посчитает последовательность «t» как символ табуляции и выдаст исключение.
Режим открытия
Ранее были упомянуты специальные символы, которые используются в языке Python при открытии файла. Они задают режим открытия файла. Указывают программе, как именно нужно открывать. Все они представлены в следующей таблице, которая содержит их сигнатуру и короткое описание назначения.
| Символ | Значение |
| «r» | открытие для чтения (по умолчанию) |
| «w» | открытие для записи, а если его не существует по заданному пути, то создается новый |
| «x» | открытие для записи, но только если его еще не существует, иначе будет выдано исключение |
| «a» | открытие на дополнительную запись, чтобы информация добавлялась в конец документа |
| «b» | открытие в двоичном режиме |
| «t» | открытие в текстовом режиме (по умолчанию) |
| «+» | открытие одновременно на чтение и запись |
Пользуясь вторым аргументом метода open, можно комбинировать различные режимы работы с файлами, указывая, к примеру, «rb» для чтения записанных данных в двоичном режиме.
Еще один пример: отличие «r+» и «w+» заключается в том, что во втором случае создастся новый файл, если такого нет. В первом же случае возникнет исключение. При использовании «r+» и «w+» файл будет открыт и на чтение и на запись. Пример обработки исключения разберем, когда будем рассматривать чтение файла.
Методы
Объект, который возвращает функция open, содержит ссылку на существующий файл. Также в нем имеется информация о созданном документе, представленная в виде четырех основных полей. Все они описаны в следующей таблице, которая содержит их имена и значение.
| Свойство | Значение |
| name | возвращает имя файла |
| mode | возвращает режим, в котором был открыт |
| closed | возвращает true, если файл закрыт и true, если открыт |
| softspace | возвращает true, если при выводе данных из файла не следует отдельно добавлять символ пробела |
Чтобы вывести на экран свойства файла, достаточно воспользоваться оператором доступа, то есть точкой, после чего передать это в качестве параметра уже знакомой функции print.
f = open(r»D:test.txt», «w») print(f.name) f.close() D:test.txt
Запись
В Python 3 запись в файл осуществляется с помощью метода write. Метод вызываем у объекта, который ссылается на существующий файл. Важно помнить, что для этого следует предварительно открыть документ с помощью функции open и указать режим записи символом «w».
Метод write принимает в качестве аргумента данные, которые нужно поместить в текстовый файл. Следующий пример кода показывает запись строки «hello».
file = open(«test.txt», «w») file.write(«hello») file.close()
Если необходимо добавить новую информацию к записанным ранее данным, следует заново вызвать функцию open, указав ей в качестве режима работы символ «a». В противном случае все сведения из файла test.txt будут полностью удалены.
В приведенном ниже примере кода текстовый документ открывается для дополнительной записи, после чего в него помещается строковый литерал “ world” с пробелом вначале. Таким образом в test.txt будет располагаться «hello world». После всего этого не нужно забывать об обязательном закрытии файла.
file = open(«test.txt», «a») file.write(» world») file.close()
Именно так осуществляется самая простая процедура записи данных в текстовый файл. Стоит заметить, что язык программирования Python содержит массу дополнительных средств для более продвинутой работы с документами, которые также включают и улучшенную запись.
Запись бинарных данных
При записи бинарных данных, следует использовать режим «wb». Вот пример записи строки в кодировке utf8:
f = open(‘test.dat’, ‘wb’) f.write(bytes(‘строка’, ‘utf8’)) f.close()
Чтение
Для чтения информации из файла в Python 3, следует вызывать метод read через объект, который ссылается на существующий документ. Также необходимо не забывать указывать «r» в качестве второго параметра функции open при открытии текстового файла.
В следующем примере read возвращает информацию из test.txt в метод print, который затем выводит сведения на экран. Как и прежде, программа завершается закрытием документа при помощи метода close. Метод read также может принимать целочисленный параметр, который используется для передачи количества символов для чтения. К примеру, введя 5, программа прочитает только hello.
try: file = open(«test.txt», «r») print(file.read()) file.close() except FileNotFoundError: print(‘Not found’) except IOError: print(‘Something else’)
Обратите внимание, что при открытии может возникнуть ошибка. Например, если указанный файл не найден. Поэтому нам пришлось обработать исключение. В Python можно воспользоваться конструкцией with, в таком случае не надо будет обрабатывать исключения и даже закрывать файл.
Её рассмотрим ниже.
Есть еще один момент: нельзя делать закрытие в секции finally блока try. Если произойдет исключение при открытии файла, то в секции finally будет ошибка.
Чтение бинарных данных
В случае, если данные бинарного вида — следует использовать «rb» в функции open. Рассмотрим пример:
try: f = open(«test.dat», «rb») b = f.read(1) str = «» while True: b = f.read(1) if b == b»: break str += b.hex() print(str) f.close() except IOError: print(‘error’) 81d182d180d0bed0bad0b0
Здесь побайтно читается файл. Каждый байт приводит к строковому виду в шестнадцатеричном представлении. С помощью функции print выводится результирующая строка.
with as
Чтобы немного автоматизировать обработку текстовых файлов, рекомендуется использовать связку операторов with as. Благодаря им пропадает необходимость в вызове метода close для документа, который необходимо закрыть, поскольку это происходит автоматически. Все это демонстрируется в следующем фрагменте кода, где происходит считывание данных из test.txt. Как обычно, метод print используется для вывода строковой информации на экран.
with open(‘test.txt’, ‘r’) as file: print(file.read())
Более того, в этом случае не нужно обрабатывать исключение. Если файла с указанным именем нету, то строки с вложенным кодом в операторе with выполняться не будут.
С помощью рассмотренных возможностей языка программирования Python, пользователь в состоянии достаточно легко выполнять основные операции по работе с чтением и записью информации в файлы.
Источник: all-python.ru