Как ставить бинарный файл на дозапись питон
Бинарные файлы в отличие от текстовых хранят информацию в виде набора байт. При открытии бинарного файла на чтение или запись также надо учитывать, что нам нужно применять режим «b» в дополнение к режиму записи («w») или чтения («r»).
При чтении мы получаем файл в виде набора байт, и наоборот, при записи в метод write() передается набор байт. Например, скопируем файл:
FILENAME = "forest.png" # файл для чтения NEWFILENAME = "forest_new.png" # файл для записи image_data = [] # список для хранения считанных данных # считываем файл в список image_data with open(FILENAME, "rb") as file: image_data = file.read() # запись выше считанных байт в новый файл with open(NEWFILENAME, "wb") as file: file.write(image_data) print(f"Файл скопирован в ")
Считывает файл, путь к которому хранится в переменной FILENAME. В данном случае это файл изображения «forest.png». Считанные байты помещаются в список image_data. Затем этот список записываем в файл с именем NEWFILENAME. Таким образом, мы скопируем содержимое одного файла в другой.
Модуль pickle
Также для работы с бинарными файлами Python предоставляет специальный встроенный модуль pickle , который упрощает работу с бинарными файлами. Этот модуль предоставляет два метода:
- dump(obj, file) : записывает объект obj в бинарный файл file
- load(file) : считывает данные из бинарного файла в объект
Допустим, надо надо сохранить значения двух переменных:
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
Запись бинарных данных в файл
Закодированное сообщение: \xff\xd8\xff\xdb\x00C\x00\x06\x04\x05\x06\x05\x04\x06\x06\x05\x06\x07\x07\x06\x08\n\xff\xd8\xff\xdb C \x06\x04\x05\x06\x05\x04\x06\x06\x05\x06\x07\x07\x06\x08\n'(44 байта) Раскодированное сообщение: x80\x03]q\x00(K\xffK\xd8K\xffK\xdbKCK\x06K\x04K\x05K\x06K\x05K\x04K\x06K\x06K\x05K\x06K\x07K\x07K\x06K\x08K\nK\xffK\xd8K\xffK\xd bK KCK K\x06K\x04K\x05K\x06K\x05K\x04K\x06K\x06K\x05K\x06K\x07K\x07K\x06K\x08K\ne. (92 байта)
Дело в том, что я записываю раскодированное сообщение с помощью коллекции. Может ли она влиять на то, как записываются данные? Кодирование битов:
f = open('s.dat', 'rb') for line in f: print(line) for c in line:#считывание строки в файле if c: g = random.randint(1, p - 1) cb = random.randint(1, p - 1) k = random.randint(1, p - 2) db = powmod(g, cb, p) print("db =", db) #r = powmod(g, k, p) e = mul(powmod(db, k, p), c, p) print("e=",e) r = powmod(g, k, p) mobs.append(e) mobsg.append(g) mobscb.append(cb) mobsk.append(k) mobsr.append(r) print("ss",mobs) Раскодирование:
for k in range(len(mobs)): deM = mul(mobs[k], powmod(mobsr[k], p - 1 - mobscb[k], p), p) print("Decrypted222 =", deM) qw=deM print(qw) mobqw.append(qw) fs = 'rez_eg.dat' with open(fs, "wb") as file: pickle.dump(mobqw, file) Запись данных в файл в текстовом и бинарном режимах
На этом занятии вы узнаете, как можно сохранять данные в файл. Первое, что нам нужно сделать – это открыть файл на запись. Для этого вторым аргументом функции 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 Частичное или полное копирование информации с данного сайта для распространения на других ресурсах, в том числе и бумажных, строго запрещено. Все тексты и изображения являются собственностью сайта
Бинарные файлы. Примеры работы с бинарными файлами
В данной теме показано как можно сохранять данные в бинарных файлах без использования стандартных средств pickle или struct языка Python.
Поиск на других ресурсах:
1. Понятие о бинарных файлах. Представление информации в бинарных файлах
В языке Python существуют средства для работы с бинарными или двоичными файлами. Бинарные файлы используют строки типа bytes . Это значит при чтении бинарных данных из файла возвращается объект типа bytes .
Открытие бинарного файла осуществляется с помощью функции open() , параметр mode которой содержит символ ‘b’ . Более подробно об открытии/закрытии бинарных файлов описывается здесь .
В отличие от текстовых, бинарные файлы не выполняют преобразования символов конца строки ‘\n’ .
Пример, демонстрирующий особенности представления информации в бинарных файлах.
# Python. Работа с бинарными файлами # Открыть бинарный файл для чтения f = open('myfile1.bin', 'rb') # Получить одну строку из бинарного файла d = f.read() # Вывести эту строку. # Будет получен вывод в виде строки символов print("d color: #ff0000;"># d = b'\x80\x03]q\x00(K\x01\x88G@\x07\n=p\xa3\xd7\ne.' # Если вывести как отдельный символ, # то будет выведен код символа - как целое число print("d[5] color: #ff0000;"># d[5] = 40 print("d[0] color: #ff0000;"># d[0] = 128 # Использовать функцию bin для отдельного символа print(bin(d[2])) # 0b1011101 f.close()
Результат работы программы
d = b'\x80\x03]q\x00(K\x01\x88G@\x07\n=p\xa3\xd7\ne.' d[5] = 40 d[0] = 128 0b1011101
На основании примера выше можно сделать следующие выводы:
- строка бинарных данных выводится как строка;
- отдельный символ (элемент) бинарных данных представлен в виде 8-битных целых чисел.
2. Запись/чтение списка, который содержит вещественные числа. Пример
# Бинарные файлы. Запись/чтение списка вещественных чисел # 1. Заданный список вещественных чисел L = [1.5, 2.8, 3.3] # 2. Запись файла # 2.1. Открыть файл для записи f = open('myfile3.bin', 'wb') # 2.2. Обход списка и запись данных в файл for item in L: # добавить символ '\n', чтобы можно было распознать числа s = str(item) + '\n' # Метод encode() - конвертирует строку в последовательность байт bt = s.encode() f.write(bt) # метод write() - запись в файл # 2.3. Закрыть файл f.close(); # 3. Считать список из бинарного файла 'myfile3.bin' # 3.1. Создать пустой список L2 = [] # 3.2. Открыть файл для чтения f = open('myfile3.bin', 'rb') # 3.3. Обход строк файла, конвертирование и добавление в список L2 for ln in f: x = float(ln) # взять число L2 = L2 + [x] # Добавить число к списку # 3.4. Вывести список print("L2 color: #ff0000;"># L2 = [1.5, 2.8, 3.3] # 3.5. Закрыть файл f.close();
Результат работы программы
L2 = [1.5, 2.8, 3.3]
3. Запись/чтение кортежа, содержащего строки символов. Пример
В данном примере строки символов в бинарном файле разделяются символом ‘\n’ . Таким образом, можно записывать и читать информацию без потери ее структуры.
# Бинарные файлы. Запись/чтение кортежа, содержащего строки символов # 1. Заданный кортеж со строками T = ( 'abc', 'def', 'ghi', 'jk lmn') # 2. Запись кортежа T в файл 'myfile5.bin' # 2.1. Открыть файл для записи f = open('myfile5.bin', 'wb') # 2.2. Цикл обхода кортежа for item in T: bt = (item + '\n').encode() # конвертировать (str + '\n') => bytes f.write(bt) # записать bt в файл # 2.3. Закрыть файл f.close(); # 3. Считать кортеж из бинарного файла 'myfile5.bin' # 3.1. Открыть файл для чтения f = open('myfile5.bin', 'rb') # 3.2. Новый кортеж T2 = () # 3.3. Прочитать данные из файла for line in f: s = line.decode() # конвертировать bytes=>str s = s[:-1] # Убрать последний символ T2 = T2 + (s,) # Добавить строку s к кортежу # 3.4. Вывести кортеж print("T2 color: #ff0000;"># 3.5. Закрыть файл f.close();
Результат работы программы
T2 = ('abc', 'def', 'ghi', 'jk lmn')
4. Запись/чтение множества, содержащего вещественные числа. Пример
Множество, которое содержит только однотипные объекты можно записать в файл. В данном примере записывается множество вещественных чисел.
# Бинарные файлы. Запись/чтение множества, # которое содержит вещественные числа # 1. Заданное множество M = < 0.2, 0.3, 0.8, 1.2, 1.77 ># 2. Запись множества M в файл 'myfile6.bin' # 2.1. Открыть файл для записи f = open('myfile6.bin', 'wb') # 2.2. Цикл обхода множества for item in M: s = str(item) + '\n' # конвертировать float=>str + '\n' bt = s.encode() # конвертировать str=>bytes f.write(bt) # записать bt в файл # 2.3. Закрыть файл f.close(); # 3. Считать множество из бинарного файла 'myfile6.bin' # 3.1. Открыть файл для чтения f = open('myfile6.bin', 'rb') # 3.2. Новое множество M2 = set() # 3.3. Прочитать данные из файла for line in f: x = float(line) # конвертировать bytes=>x M2 = M2.union() # Добавить x к множеству # 3.4. Вывести множество print("M2 color: #ff0000;"># 3.5. Закрыть файл f.close()
Результат работы программы
Вид файла myfile6.bin
0.2 0.8 1.77 0.3 1.2
5. Запись/чтение двумерной матрицы строк заданного размера. Пример
В примере матрица представлена в виде списка.
# Бинарные файлы. Запись/чтение матрицы, которая содержит строки # 1. Заданная матрица строк размером 3*4 MATRIX = [ [ 'aa', 'ab', 'ac', 'ad'], [ 'ba', 'bb', 'bc', 'bd'], [ 'ca', 'cb', 'cc', 'cd'] ] # 2. Запись матрицы MATRIX в файл 'myfile7.bin' # 2.1. Открыть файл для записи f = open('myfile7.bin', 'wb') # 2.2. Сначала записать размер матрицы m = 3 n = 4 # конвертировать m, n в строчный тип str sm = str(m) + '\n' sn = str(n) + '\n' # конвертировать строку str в bytes bm = sm.encode() bn = sn.encode() # записать размеры матрицы в файл f.write(bm) f.write(bn) # 2.3. Цикл обхода матрицы for row in MATRIX: # здесь нужно просто записать строки с символом '\n' for item in row: item = item + '\n' bt = item.encode() # str=>bytes f.write(bt) # записать bt в файл # 2.3. Закрыть файл f.close(); # 3. Считать матрицу из бинарного файла 'myfile7.bin' # 3.1. Открыть файл для чтения f = open('myfile7.bin', 'rb') # 3.2. Новая матрица MATRIX2 = [] # 3.3. Прочитать данные из файла # 3.3.1. Сначала прочитать размер s = f.readline() m2 = int(s) s = f.readline() n2 = int(s) # 3.3.2. Цикл чтения строк и создание матрицы размером m2*n2 i = 0 while i < m2: # m2 строк в матрице row = [] # одна строка списка j = 0 while j < n2: bs = f.readline() # прочитать один элемент типа bytes s = bs.decode() # конвертировать bytes=>str s = s[:-1] # убрать '\n' row += [s] # добавить к списку j = j+1 MATRIX2 += [row] # добавить одну строку списка к матрице i = i+1 # 3.4. Вывести новую матрицу i = 0 while i < m2: print("MATRIX2[", i, "] color: #ff0000;"># 3.5. Закрыть файл f.close()
Результат работы программы
MATRIX2[ 0 ] = ['aa', 'ab', 'ac', 'ad'] MATRIX2[ 1 ] = ['ba', 'bb', 'bc', 'bd'] MATRIX2[ 2 ] = ['ca', 'cb', 'cc', 'cd']
Вид файла myfile7.txt
3 4 aa ab ac ad ba bb bc bd ca cb cc cd
6. Запись/чтение словаря. Пример
Пусть задан некоторый словарь, который нужно записать в бинарный файл.
# Бинарные файлы. Запись/чтение словаря # 1. Заданный словарь. Пары типа str:int D = < 'One':1, 'Two':2, 'Three':3, 'Four':4 > # 2. Запись словаря D в файл 'myfile8.bin' # 2.1. Открыть файл для записи f = open('myfile8.bin', 'wb') for key in D: # обход словаря # взять значение value value = D[key] # Записать последовательно key, затем value svalue = str(value) + '\n' # сначала конвертировать value в строку skey = key + '\n' # к строке key добавить '\n' # Конвертировать key:svalue из строки в bytes b_key = skey.encode() b_svalue = svalue.encode() # записать b_key, b_svalue в файл f.write(b_key) f.write(b_svalue) # 2.3. Закрыть файл f.close(); # 3. Считать словарь из бинарного файла 'myfile8.bin' # 3.1. Открыть файл для чтения f = open('myfile8.bin', 'rb') # 3.2. Новый словарь, который будет прочитан из файла D2 = dict() # 3.3. Прочитать весь файл сразу b_strings = f.readlines() # b_strings - список строк типа bytes # 3.4. Обойти список b_strings. # Сначала читается ключ, затем значение и т.д. fkey = True # если True, то читается ключ, иначе читается значение for item in b_strings: if fkey: # проверка, если читается ключ skey = item.decode() # конвертировать bytes=>str key = skey[:-1] # убрать '\n' fkey = False else: svalue = item.decode() # конвертировать bytes=>str value = int(svalue) # конвертировать str=>int D2[key] = value # добавить к словарю fkey = True # указать, что на следующей итерации будет ключ # 3.5. Вывести словарь print("D2 color: #ff0000;"># 3.6. Закрыть файл f.close()
Результат работы программы
D2 = 'One': 1, 'Two': 2, 'Three': 3, 'Four': 4>
Вид файла myfile8.txt
One 1 Two 2 Three 3 Four 4
7. Копирование одного бинарного файла в другой
# Бинарные файлы. Копирование файлов # 1. Открыть файлы f1 = open('myfile8.bin', 'rb') # файл - источник, открывается для чтения f2 = open('copyfile8.bin', 'wb') # файл - копия # 2. Считать файл f1 в список строк bstrings bstrings = f1.readlines() # 3. Записать список строк bstrings в файл f2 f2.writelines(bstrings) # 4. Закрыть файлы f1.close() f2.close()
8. Объединение двух бинарных файлов. Пример
В примере реализована операция объединения двух файлов в результирующий третий файл. Сначала данные с файлов-источников считываются в списки. Затем происходит конкатенация этих списков и запись результирующего списка в файл результата.
# Объединение файлов myfile1.bin+myfile2.bin => myfile3.bin # 1. Открыть файлы для чтения f1 = open('myfile1.bin', 'rb') f2 = open('myfile2.bin', 'rb') # 2. Считать файлы в списки L1, L2 L1 = f1.readlines() L2 = f2.readlines() # 3. Объединить списки L3 = L1 + L2 # 4. Закрыть файлы myfile1.bin, myfile2.bin f1.close() f2.close() # 5. Открыть файл myfile3.bin для записи f3 = open('myfile3.bin', 'wb') # 6. Записать строки в файл f3.writelines(L3) # 7. Закрыть результирующий файл f3.close()
Связанные темы
- Файлы. Общие понятия. Открытие/закрытие файла. Функции open() , close()
- Примеры работы с текстовыми файлами