Работа с файлами
Любая программа, которая выполняется на компьютере пользователя скорее всего взаимодействует с файловой системой: умеет открывать файлы, сохранять их в своих форматах, возможно, хранит в файлах настройки.
Сегодня наши программы тоже смогут так делать!
Что такое файл?
До этого момента вся информация, с которой мы работали, хранилась исключительно в оперативной памяти — в переменных.
Но информация из оперативной пропадает при закрытии программы или перезагрузке компьютера. Что делать с данными, которые нужно хранить между запусками? Единственное решение — это хранить данные на энергонезависимом носителе — жестком диске (HDD) или твердотельном накопителе (SSD). Далее будет использоваться термин жесткий диск, хотя подразумевается любое из этих устройств.
Участок жесткого диска, у которого есть имя называется файлом.
Также, как и переменные, файлы занимают какое-то место, их размер измеряется в байтах.
Способ организации и хранения файлов на диске называется файловой системой.
Текстовые и бинарные файлы
С точки зрения прикладных программ файлы делятся на два основных типа: текстовые и бинарные. Физически оба типа файлов не отличаются и хранят в себе байты с данными, отличается лишь их интерпретация нашей программой.
В текстовых файлах хранятся текстовые данные. В зависимости от кодировки каждый символ кодируется равным числом байт.
Текстовые файлы могут иметь произвольные расширения, вам, возможно встречались .txt, .py, .html.
Текстовые файлы можно открыть в текстовом редакторе, например, в блокноте.
В бинарных файлах хранятся произвольные данные: символы, числа, дроби, но разные объекты могут кодироваться разным числом байт.
Как интерпретировать ту или иную группу байт в файле, нам говорит формат файла. Примеры бинарных файлов: .exe, .doc, .dll и тд..
Если открыть бинарный файл в блокноте, вы увидите много страшных символов — компьютер попытается интерпретировать все данные в файле как буквы.
Создаем текстовый файл
При работе с файлами всегда используется следующий алгоритм:
- открытие файла
- изменение или чтение файла
- закрытие файла
Не забудьте закрыть файл, если он вам больше не нужен, иначе другие программы не смогут открыть его. Операционная система следит за тем, чтобы файлом в один момент управляла только одна программа.
Чтобы открыть файл, в питоне используется функция open(path, mode) , которая принимает путь к файлу (абсолютный или относительный) и режим. Режим — это либо чтение (read), либо запись (write), либо добавление в конец файла (append).
Если файл открыт только для чтения, то записать данные в него нельзя. Нужно закрыть его и открыть в другом режиме.
Давайте создадим текстовый файл и запишем туда небольшой текст:
file = open('new.txt', 'w') # открываем файл new.txt для записи (w) file.write("hello world! :)") # записываем строку в файл file.close() # закрываем файлОбратите внимание: если открыть файл для записи, старые данные из него автоматически стираются.
После выполнения программы, в папке с кодом должен появиться новый файл new.txt, а в нем — строка «hello world».
Читаем текстовый файл
Аналогично записи в текстовый файл, мы можем открыть его для чтения и прочитать все его содержимое в переменную.
file = open('smiles.txt', 'r') # открываем файл smiles.txt для чтения (r) text = file.read() # считываем все содержимое файла в переменную file.close() print(text[:100])Файл smiles.txt можно скачать тут.
Используем with
Чтобы случайно не забыть закрыть файл после окончания работы с ним, используйте обертку with . Она автоматически закроет файл, как только закончится ее область видимости.
Пример:
with open('smiles.txt', 'r') as file: text = file.read() # файл автоматически закрылся print(text[:100])Запись данных в файл в текстовом и бинарном режимах
На этом занятии вы узнаете, как можно сохранять данные в файл. Первое, что нам нужно сделать – это открыть файл на запись. Для этого вторым аргументом функции open() следует указать строку «w»:
file = open("out.txt", "w")
(Если не указывать ничего, как это мы делали на прошлых уроках, то файл будет открыт на чтение, или же, можно явно прописать «r» – значение по умолчанию).
Итак, мы открыли файл на запись и далее, чтобы поместить в него какую-либо текстовую информацию следует вызвать метод write, следующим образом:
file.write("Hello World!") file.close()
В результате будет создан файл out.txt (если его ранее не было) со строкой «Hello World!». Причем, этот файл будет располагаться в том же каталоге, что и исполняемый файл. Также после записи всей нужной информации в файл, его следует обязательно закрывать! Иначе, часть информации может не сохраниться. Как я уже говорил, метод close() нужно вызывать всегда после завершения работы с файлом.
Отлично, это у нас получилось! Давайте теперь запишем метод write со строкой «Hello»:
file.write("Hello")
и снова выполним эту программу. Смотрите, в нашем файле out.txt прежнее содержимое исчезло и появилось новое – строка «Hello». То есть, когда мы открываем файл на запись, то прежнее содержимое удаляется. Вот этот очень важный момент всегда следует иметь в виду – открывая файл на запись, его прежнее содержимое автоматически удаляется!
Те из вас, кто смотрел предыдущее занятие, сейчас могут заметить, что при открытии файла на запись могут возникать различные файловые ошибки, поэтому критический блок (кода открытия файла и записи информации) лучше поместить в блок try, а все операции с файлом выполнять через менеджер контекста:
try: with open("out.txt", "w") as file: file.write("Hello World!") except: print("Ошибка при работе с файлом")
Об этом всегда следует помнить, при работе с файлами! Чтобы программа работала надежно даже в нештатных ситуациях, необходима конструкция try / except и менеджер контекста with.
Давайте теперь посмотрим, что будет, если вызвать метод write несколько раз подряд для одного и того же открытого файла:
file.write("Hello1") file.write("Hello2") file.write("Hello3")
Смотрите, в файле появились все эти строчки друг за другом. То есть, здесь как и со считыванием, объект file записывает информацию, используя файловую позицию, и автоматически перемещает ее при выполнении записи новых данных. Поэтому все эти строки идут в файле друг за другом.
Если мы хотим, чтобы эти строки шли друг под другом, то в конце каждой из них достаточно указать символ переноса строки:
file.write("Hello1\n") file.write("Hello2\n") file.write("Hello3\n")
Однако, если нам все же нужно, мы можем выполнять дозапись информации в файл. Для этого его следует открыть в режиме ‘a’ (сокращение от англ. слова append – добавление):
with open("out.txt", "a") as file: .
Выполняя эту программу, мы видим в файле уже шесть строчек.
Но будьте аккуратны. Если мы открываем файл на запись или дозапись, то читать информацию из этого файла уже не получится. Например, если попытаться воспользоваться методом read():
file.read()
то возникнет ошибка. Чтобы ее увидеть я поставлю комментарии у блока try и снова запущу программу. Видим исключение UnsupportedOperation.
Если же мы хотим и записывать и считывать информацию, то можно воспользоваться режимом a+:
file = open("out.txt", "a+")
Так как здесь файловый указатель стоит на последней позиции, то для считывания информации, поставим его в самое начало:
file.seek(0) print( file.read() )
А вот запись данных всегда осуществляется в конец файла, так как для записи используется другая файловая позиция и она указывает на конец файла.
Далее, если нам нужно записать несколько строк, представленных в какой-либо коллекции, то удобно воспользоваться методом writelines():
file.writelines(["Hello1\n", "Hello2\n"])
Это часто используется, если в процессе обработки текста у нас получается список из строк и его требуется целиком поместить в файл. Здесь метод writelines() незаменим.
Чтение и запись в бинарном режиме доступа
До сих пор мы с вами говорили о чтении и записи информации в текстовом режиме доступа. Есть еще другой – бинарный режим работы с файлами. Что такое бинарный режим доступа? Это когда данные из файла считываются один в один без какой-либо обработки. Обычно он используется для сохранения и считывания объектов целиком. Давайте предположим, что нам нужно сохранить в файл вот такой список:
books = [ ("Евгений Онегин", "Пушкин А.С.", 200), ("Муму", "Тургенев И.С.", 250), ("Мастер и Маргарита", "Булгаков М.А.", 500), ("Мертвые души", "Гоголь Н.В.", 190) ]
Для этого откроем файл на запись в бинарном режиме:
file = open("out.bin", "wb")
Затем, для работы с бинарными данными подключим специальный встроенный модуль pickle:
import pickle
И вызовем его метод dump:
pickle.dump(books, file)
Все, мы сохранили этот объект в файл. Теперь прочитаем эти данные. Откроем файл на чтение в бинарном режиме:
file = open("out.bin", "rb")
и вызовем метод load модуля pickle:
bs = pickle.load(file)
Все, теперь переменная bs ссылается на эквивалентный список:
print( bs )
Аналогичным образом можно записывать и считывать сразу несколько объектов. Например, так:
import pickle book1 = ["Евгений Онегин", "Пушкин А.С.", 200] book2 = ["Муму", "Тургенев И.С.", 250] book3 = ["Мастер и Маргарита", "Булгаков М.А.", 500] book4 = ["Мертвые души", "Гоголь Н.В.", 190] try: with open("out.bin", "wb") as file: pickle.dump(book1, file) pickle.dump(book2, file) pickle.dump(book3, file) pickle.dump(book4, file) except: print("Ошибка при работе с файлом")
А, затем, считывание в том же порядке:
import pickle try: with open("out.bin", "rb") as file: b1 = pickle.load(file) b2 = pickle.load(file) b3 = pickle.load(file) b4 = pickle.load(file) except: print("Ошибка при работе с файлом") print( b1, b2, b3, b4, sep="\n" )
Вот так в Python выполняется запись и считывание данных в бинарном режиме.
Надеюсь, из этого занятия вам стало понятно, как производится запись данных в файл, как делать дозапись информации, что такое бинарный и текстовый режимы доступа и как записывать и считывать информацию в бинарном режиме с помощью методов модуля pickle. До встречи на следующем занятии!
Видео по теме
#1. Первое знакомство с Python Установка на компьютер
#2. Варианты исполнения команд. Переходим в PyCharm
#3. Переменные, оператор присваивания, функции type и id
#4. Числовые типы, арифметические операции
#5. Математические функции и работа с модулем math
#6. Функции print() и input(). Преобразование строк в числа int() и float()
#7. Логический тип bool. Операторы сравнения и операторы and, or, not
#8. Введение в строки. Базовые операции над строками
#9. Знакомство с индексами и срезами строк
#10. Основные методы строк
#11. Спецсимволы, экранирование символов, row-строки
#12. Форматирование строк: метод format и F-строки
#13. Списки — операторы и функции работы с ними
#14. Срезы списков и сравнение списков
#15. Основные методы списков
#16. Вложенные списки, многомерные списки
#17. Условный оператор if. Конструкция if-else
#18. Вложенные условия и множественный выбор. Конструкция if-elif-else
#19. Тернарный условный оператор. Вложенное тернарное условие
#20. Оператор цикла while
#21. Операторы циклов break, continue и else
#22. Оператор цикла for. Функция range()
#23. Примеры работы оператора цикла for. Функция enumerate()
#24. Итератор и итерируемые объекты. Функции iter() и next()
#25. Вложенные циклы. Примеры задач с вложенными циклами
#26. Треугольник Паскаля как пример работы вложенных циклов
#27. Генераторы списков (List comprehensions)
#28. Вложенные генераторы списков
#29. Введение в словари (dict). Базовые операции над словарями
#30. Методы словаря, перебор элементов словаря в цикле
#31. Кортежи (tuple) и их методы
#32. Множества (set) и их методы
#33. Операции над множествами, сравнение множеств
#34. Генераторы множеств и генераторы словарей
#35. Функции: первое знакомство, определение def и их вызов
#36. Оператор return в функциях. Функциональное программирование
#37. Алгоритм Евклида для нахождения НОД
#38. Именованные аргументы. Фактические и формальные параметры
#39. Функции с произвольным числом параметров *args и **kwargs
#40. Операторы * и ** для упаковки и распаковки коллекций
#41. Рекурсивные функции
#42. Анонимные (lambda) функции
#43. Области видимости переменных. Ключевые слова global и nonlocal
#44. Замыкания в Python
#45. Введение в декораторы функций
#46. Декораторы с параметрами. Сохранение свойств декорируемых функций
#47. Импорт стандартных модулей. Команды import и from
#48. Импорт собственных модулей
#49. Установка сторонних модулей (pip install). Пакетная установка
#50. Пакеты (package) в Python. Вложенные пакеты
#51. Функция open. Чтение данных из файла
#52. Исключение FileNotFoundError и менеджер контекста (with) для файлов
#53. Запись данных в файл в текстовом и бинарном режимах
#54. Выражения генераторы
#55. Функция-генератор. Оператор yield
#56. Функция map. Примеры ее использования
#57. Функция filter для отбора значений итерируемых объектов
#58. Функция zip. Примеры использования
#59. Сортировка с помощью метода sort и функции sorted
#60. Аргумент key для сортировки коллекций по ключу
#61. Функции isinstance и type для проверки типов данных
#62. Функции all и any. Примеры их использования
#63. Расширенное представление чисел. Системы счисления
#64. Битовые операции И, ИЛИ, НЕ, XOR. Сдвиговые операторы
#65. Модуль random стандартной библиотеки
#66. Аннотация базовыми типами
#67. Аннотации типов коллекций
#68. Аннотации типов на уровне классов
#69. Конструкция match/case. Первое знакомство
#70. Конструкция match/case с кортежами и списками
#71. Конструкция match/case со словарями и множествами
#72. Конструкция match/case. Примеры и особенности использования
© 2024 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Как ставить бинарный файл на дозапись питон
Бинарные файлы в отличие от текстовых хранят информацию в виде набора байт. Для работы с ними в Python необходим встроенный модуль pickle . Этот модуль предоставляет два метода:
- dump(obj, file) : записывает объект obj в бинарный файл file
- load(file) : считывает данные из бинарного файла в объект
При открытии бинарного файла на чтение или запись также надо учитывать, что нам нужно применять режим «b» в дополнение к режиму записи («w») или чтения («r»). Допустим, надо надо сохранить два объекта:
import pickle FILENAME = "user.dat" name = "Tom" age = 19 with open(FILENAME, "wb") as file: pickle.dump(name, file) pickle.dump(age, file) with open(FILENAME, "rb") as file: name = pickle.load(file) age = pickle.load(file) print("Имя:", name, "\tВозраст:", age)
С помощью функции dump последовательно записываются два объекта. Поэтому при чтении файла также последовательно посредством функции load мы можем считать эти объекты. Консольный вывод программы:
Имя: Tom Возраст: 28
Подобным образом мы можем сохранять и извлекать из файла наборы объектов:
import pickle FILENAME = "users.dat" users = [ ["Tom", 28, True], ["Alice", 23, False], ["Bob", 34, False] ] with open(FILENAME, "wb") as file: pickle.dump(users, file) with open(FILENAME, "rb") as file: users_from_file = pickle.load(file) for user in users_from_file: print("Имя:", user[0], "\tВозраст:", user[1], "\tЖенат(замужем):", user[2])
В зависимости от того, какой объект мы записывали функцией dump, тот же объект будет возвращен функцией load при считывании файла.
Имя: Tom Возраст: 28 Женат(замужем): True Имя: Alice Возраст: 23 Женат(замужем): False Имя: Bob Возраст: 34 Женат(замужем): False
Чтение бинарных файлов с помощью Python
Файл, содержащий бинарные данные, называется двоичным (бинарным) файлом. Любые форматированные и неформатированные бинарные данные хранятся в бинарных файлах, нечитабельных для человека и использующихся компьютером напрямую.
Когда бинарный файл требуется просмотреть или переместить, содержимое файла переводится в формат, понятный человеку. Бинарный файл имеет расширение .bin. Прочитать его можно с помощью встроенной функции или модуля. В этом уроке мы разберём различные способы чтения бинарных файлов с помощью Python.
Подготовка
Перед тем, как начать урок, желательно создать один или несколько бинарных файлов, чтобы воспользоваться скриптом из примера. Ниже представлены два скрипта на Python, которые создадут два бинарника. Файл binary1.py создаёт string.bin, содержащий строковые данные, а binary2.py – number_list.bin со списком из числовых данных.
Binary1.py
# Создаём бинарный файл file_handler = open("string.bin", "wb") # Добавляем две строки в бинарный файл file_handler.write(b"Welcome to LinuxHint.\nLearn Python Programming.") # Закрываем чтение file_handler.close()
Binary2.py
# Создаём бинарный файл file=open("number_list.bin","wb") # Объявляем список с числовыми данными numbers=[10,30,45,60,70,85,99] # Конвертируем список в массив barray=bytearray(numbers) # Записываем массив в файл file.write(barray) file.close()
Считываем бинарный файл со строковыми данными в массив байтов
В Python существует множество способов прочитать бинарный файл. Можно прочитать определённое количество байтов или весь файл сразу.
В приведенном ниже коде функция open() открывает для чтения string.bin, а функция read() на каждой итерации цикла while считывает по 7 символов в файле и выводит их. Далее мы используем функцию read() еще раз, но уже без аргументов — для считывания всего файла. После считывания содержимое выводится на экран.
# Открываем бинарный файл на чтение file_handler = open("string.bin", "rb") # Читаем первые 7 байтов из файла data_byte = file_handler.read(7) print("Print three characters in each iteration:") # Проходим по циклу, чтобы считать оставшуюся часть файла while data_byte: print(data_byte) data_byte = file_handler.read(7) # Записываем всё содержимое файла в байтовую строку with open('string.bin', 'rb') as fh: content = fh.read() print("Print the full content of the binary file:") print(content)
Результат
После выполнения скрипта мы получим следующий результат.
Считываем бинарный файл со строковыми данными в массив
Следующий скрипт поможет нам прочитать бинарник number_list.bin, созданный нами ранее.
# Открываем на чтение бинарный файл file = open("number_list.bin", "rb") # Считываем в список первые 5 элементов number = list(file.read(5)) # Выводим список print(number) # Закрываем файл file.close()
Бинарный файл содержит список с числовыми данными. Как и в предыдущем примере, функция open() открывает файл и читает из него данные. Затем из бинарника читаются первые 5 чисел и перед выводом объединяются в список.
Результат
После выполнения скрипта мы получим следующий результат. Бинарный файл содержит 7 чисел, первые 5 вывелись на консоль.
Читаем бинарный файл с помощью NumPy
В этой части мы поговорим о том, как создать бинарный файл и прочитать его с помощью массивов NumPy. Перед началом работы необходимо установить модуль NumPy командой в терминале или через ваш редактор Python, в котором вы будете писать программу.
Функция tofile() создаёт текстовый или бинарный файл, а fromfile() считывает данные из файла и создаёт массив.
Синтаксис tofile()
ndarray.tofile(file, sep='', format='%s')
Первый аргумент обязательный – он принимает имя файла, путь или строку. Файл создастся, только если будет указан первый аргумент. Второй аргумент – необязательный, он используется для разделения элементов массива. Третий аргумент также необязателен, он отвечает за форматированный вывод содержимого файла.
Синтаксис fromfile()
numpy.fromfile(file, dtype=float, count=- 1, sep='', offset=0, *, like=None)
Первый аргумент обязательный – он принимает имя файла, путь или строку. Содержимое файла будет прочитано, только если вы укажете имя файла. dtype определяет тип данных в возвращаемом массиве. Count задаёт число элементов массива. Sep – для разделения элементов текста или массива. Offset определяет позицию в файле, с которой начинается считывание. Последний аргумент нужен, чтобы создать массив, не являющийся массивом NumPy.
Напишем следующий код, чтобы создать бинарный файл с помощью массива NumPy, прочитать его и вывести содержимое.
# Импортируем NumPy import numpy as np # Объявляем массив numpy nparray = np.array([34, 89, 30, 45, 90, 11]) # Создаём бинарный файл из numpy-массива nparray.tofile("list.bin") # Выведем данные из бинарного файла print(np.fromfile("list.bin", dtype=np.int64))
Результат
После выполнения скрипта мы увидим следующий результат.
Заключение
Мы рассмотрели 3 разных способа чтения бинарных файлов. В первом примере мы получили содержимое файла в виде массива байтов, во втором и третьем – в виде списка.