Работа с файлами python егэ

Доброго времени суток каждому жителю Хабрвилля! Давненько я не писал статей! Пора это исправить!

В сегодняшней статье поговорим о насущной для многих выпускников школ теме — ЕГЭ. Да-да-да! Я знаю, что Хабр — это сообщество разработчиков, а не начинающих айтишников, но сейчас ребятам как никогда нужна поддержка именно сообщества. Ребят опять посадили на дистант. Пока не ясно на какой период, но уже сейчас можно сказать, что ЕГЭ по информатике будет на компьютерах и его можно зарешать при помощи языка Python.

Вот я и подумал, чтобы не получилось как в песне, стоит этим заняться. Я расскажу про все задачи первой части и их решения на примере демо варианта ЕГЭ за октябрь.

Всех желающих — приглашаю ниже!

Быстрый перевод из системы в систему

В Python есть интересные функции bin(), oct() и hex(). Работают данные функции очень просто:

bin(156) #Выводит '0b10011100'
oct(156) #Выводит '0o234'
hex(156) #Выводит '0x9c'

Как вы видите, выводится строка, где 0b — означает, что число далее в двоичной системе счисления, 0o — в восьмеричной, а 0x — в шестнадцатеричной. Но это стандартные системы, а есть и необычные…

Давайте посмотрим и на них:

n = int(input()) #Вводим целое число
 
b = '' #Формируем пустую строку
 
while n > 0: #Пока число не ноль
    b = str(n % 2) + b #Остатот от деления нужной системы (в нашем сл записываем слева
    n = n // 2 #Целочисленное деление
 
print(b) #Вывод

Данная программа будет работать при переводе из десятичной системы счисления в любую до 9, так как у нас нет букв. Давайте добавим буквы:

n = int(input()) #Вводим целое число

b = '' #Формируем пустую строку

while n > 0: #Пока число не ноль
	if (n % 21) > 9: #Если остаток от деления больше 9...
		if n % 21 == 10: #... и равен 10...
			b = 'A' + b #... запишем слева A
		elif n % 21 == 11:#... и равен 11...
			b = 'B' + b#... запишем слева B

'''

И так далее, пока не дойдём до системы счисления -1 (я переводил в 21-ную систему и шёл до 20)

'''

		elif n % 21 == 11:
			b = 'B' + b
		elif n % 21 == 12:
			b = 'C' + b
		elif n % 21 == 13:
			b = 'D' + b
		elif n % 21 == 14:
			b = 'E' + b
		elif n % 21 == 15:
			b = 'F' + b
		elif n % 21 == 16:
			b = 'G' + b
		elif n % 21 == 17:
			b = 'H' + b
		elif n % 21 == 18:
			b = 'I' + b
		elif n % 21 == 19:
			b = 'J' + b
		elif n % 21 == 20:
			b = 'K' + b
	else: #Иначе (остаток меньше 10)
		b = str(n % 21) + b #Остатот от деления записываем слева
	n = n // 21 #Целочисленное деление

print(b) #Вывод

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

def convert_base(num, to_base=10, from_base=10):
    # Перевод в десятичную систему
    if isinstance(num, str): # Если число - строка, то ...
        n = int(num, from_base) # ... переводим его в нужную систему счисления
    else: # Если же ввели число, то ...
        n = int(num) # ... просто воспринять его как число
    # Перевод десятичной в 'to_base' систему
    alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" # Берём алфавит
    if n < to_base: # Если число меньше системы счисления в которую переводить...
        return alphabet[n] # ... вернуть значения номера в алфавите (остаток от деления)
    else: # Иначе...
        return convert_base(n // to_base, to_base) + alphabet[n % to_base] # ... рекурсивно обратиться к функии нахождения остатка

Вызвав функцию вывода print(convert_base(156, 16, 10)) мы переведём 156 из 10 в 16 систему счисления, а введя print(convert_base('23', 21, 4)) переведёт 23 из 4-ичной в 21-ичную систему (ответ: B).

Задача 2

Все задания беру из первого октябрьского варианта (он же вариант № 9325894) с сайта Решу.ЕГЭ.

Решение данной задачи совсем простое: банальный перебор.

print('y', 'x', 'z', 'F') #Напечатаем заголовки таблицы
for y in range(2): #Берём все переменные и меняем их в циклах '0' и '1'
	for x in range(2):
		for z in range(2):
			for w in range(2):
				F = ((not x or y) == (not z or w)) or (x and w) #Записываем функцию
				print(x, y, z, F) #Выводим результат

Результат:

Нам вывелась вся таблица истинности (1 = True, 0 = False). Но это не очень удобно. Обратите внимание, что в задании, функция равно 0, так и давайте подправим код:

print('y', 'x', 'z', 'F') #Напечатаем заголовки таблицы
for y in range(2): #Берём все переменные и меняем их в циклах '0' и '1'
	for x in range(2):
		for z in range(2):
			for w in range(2):
				F = ((not x or y) == (not z or w)) or (x and w) #Записываем функцию
				if not F:
					print(x, y, z, F) #Выводим результат

Результат:

Далее — простой анализ.

Задача 5

Данная задача легко решается простой последовательностью действий в интерпретационном режиме:

Задача 6

Перепечатали и получили ответ:

s = 0
k = 1
while s < 66:
    k += 3
    s += k
print(k)

Задача 12

В очередной раз, просто заменим слова на код:

a = '9' * 1000

while '999' in a or '888' in a:
	if '888' in a:
		a = a.replace('888', '9', 1)
	else:
		a = a.replace('999', '8', 1)
print(a)

Задача 14

Компьютер железный, он всё посчитает:

a = 4 ** 2020 + 2 ** 2017 - 15
k = 0

while a > 0:
    if a % 2 == 1:
    	k += 1
    a = a // 2

print(k)

Задача 16

Опять же, просто дублируем программу в python:

def F(n):
    if n > 0:
        F(n // 4)
        print(n)
        F (n - 1)
print(F(5))

Результат:

Задача 17

Задача с файлом. Самое сложное — достать данные из файла. Но где наша не пропадала?!

with open("17.txt", "r") as f: #Открыли файл 17.txt для чтения
    text = f.read() #В переменную text запихнули строку целиком
a = text.split("n") #Разбили строку энтерами (n - знак перехода на новую строку)

k = 0 #Стандартно обнуляем количество
m = -20001 #Так как у нас сумма 2-ух чисел и минимальное равно -10000, то минимум по условию равен -20000, поэтому...

for i in range(len(a)): #Обходим все элементы массива
	if (int(a[i - 1]) % 3 == 0) or (int(a[i]) % 3 == 0): #Условное условие
		k += 1 #Счётчик
		if int(a[i - 1]) + int(a[i]) > m: #Нахождение минимума
			m = int(a[i - 1]) + int(a[i])

print(k, m) #Вывод

Немного пояснений. Функция with() открывает файл считывает данные при помощи функции read() и закрывает файл. В остальном — задача стандартна.

Задача 19, 20 и 21

Все три задачи — задачи на рекурсию. Задачи идентичны, а вопросы разные. Итак, первая задача:

Пишем рекурсивную функцию и цикл перебора S:

def f(x, y, p): #Рекурсивная функция
	if x + y >= 69 or p > 3: #Условия завершения игры
		return p == 3
	return f(x + 1, y, p + 1) or f(x, y + 1, p + 1) or
		   f(x * 2, y, p + 1) or f(x, y * 3, p + 1) #Варианты действий

for s in range (1, 58 + 1): #Перебор S
	if f(10, s, 1): #Начали с 10 камней
		print(s)
		break

Немного пояснений. В рекурсивной функции существует 3 переменные x — число камней в первой куче, y — число камней во второй куче, p — позиция. Позиция рассчитывается по таблице:

Далее — всё по условию задачи.

Вторая задача на теорию игр:

Все отличия в рамке. Ну и код, соответственно, не сильно отличается:

def f(x, y, p): #Рекурсивная функция
	if x + y >= 69 or p > 4: #Условия завершения игры
		return p == 4
	if p % 2 != 0:
		return f(x + 1, y, p + 1) or f(x, y + 1, p + 1) or
			   f(x * 2, y, p + 1) or f(x, y * 3, p + 1) #Варианты действий
	else:
		return f(x + 1, y, p + 1) and f(x, y + 1, p + 1) and
			   f(x * 2, y, p + 1) and f(x, y * 3, p + 1) #Варианты действий


for s in range (1, 58 + 1): #Перебор S
	if f(10, s, 1): #Начали с 10 камней
		print(s)

Отличия:

1. Выиграл Петя, соответственно, позиция 4

2. Так как Петя не может выиграть за один ход — он выигрывает за 2 хода (and, а не or на нечётных позициях (играх Пети))

3. Убрали break, так как нам нужны все S, а не единственный

Последняя вариация задачи:

Сразу код:

def f(x, y, p): #Рекурсивная функция
	if x + y >= 69 or p > 5: #Условия завершения игры
		return p == 3 or p == 5
	if p % 2 == 0:
		return f(x + 1, y, p + 1) or f(x, y + 1, p + 1) or
			   f(x * 2, y, p + 1) or f(x, y * 3, p + 1) #Варианты действий
	else:
		return f(x + 1, y, p + 1) and f(x, y + 1, p + 1) and
			   f(x * 2, y, p + 1) and f(x, y * 3, p + 1) #Варианты действий


for s in range (1, 58 + 1): #Перебор S
	if f(10, s, 1): #Начали с 10 камней
		print(s)

Ну и всего лишь 2 отличия:

1. Позиции 3 или 5, а не 4, так как выиграл Ваня

2. На второй ход выигрывает Ваня и нам нужно or и and поменять. Я заменил только кратность 2.

Задача 22

Ctrl+C, Ctrl+V — наше всё!

for i in range(1, 100000):
	x = i
	L = 0
	M = 0
	while x > 0 :
		L = L+1
		if (x % 2) != 0:
			M = M + x % 8
		x = x // 8
	if L == 3 and M == 6:
		print(i)

Задача 23

Итак, код:

def f(x, y):
	if x > y: #Перегнали цель
		return 0
	if x == y:  #Догнали цель
		return 1
	if x < y: #Догоняем цель тремя методами
		return f(x + 1, y) + f(x + 2, y) + f(x * 2, y)

print(f(3, 10) * f(10, 12)) #Прошло через 10, значит догнали 10 и от де догоняем 12

Так как в условии задачи мы увеличиваем число, но будем числа «догонять». Три метода описаны, ну а пройти через 10 — значит дойти до него и идти от него.

Собственно, это и есть вся первая часть ЕГЭ по информатике решённая на Python.

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

Надеюсь, что смог помочь в своей статье выпускникам и готовящимся

Остался один вопрос — нужен ли разбор второй части ЕГЭ по информатике на Python? Оставлю этот вопрос на ваше голосование.

Всем удачи!

Делаю разбор второй части?

Проголосовали 106 пользователей.

Воздержались 15 пользователей.

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

Файл — это всего лишь набор данных, сохраненный в виде последовательности битов на компьютере. Информация хранится в куче данных (структура данных) и имеет название «имя файла» (filename).

В Python существует два типа файлов:

1. Текстовые
2. Бинарные

Текстовые файлы

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

Текст может храниться в двух форматах: (.txt) — простой текст и (.rtf) — «формат обогащенного текста».

Бинарные файлы

В бинарных файлах данные отображаются в закодированной форме (с использованием только нулей (0) и единиц (1) вместо простых символов). В большинстве случаев это просто последовательности битов.

Они хранятся в формате .bin.

Любую операцию с файлом можно разбить на три крупных этапа:

1. Открытие файла
2. Выполнение операции (запись, чтение)
3. Закрытие файла

Открытие файла

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

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

open(file
[, mode=’r’, encoding=None, …])

через которую и
осуществляется работа с файлами. Здесь

• file – это путь к
  файлу вместе с его именем;

• mode – режим доступа
  к файлу;

• encoding
  – кодировка
  файла.

Для начала определимся с понятием «путь
к файлу». Представим, что наш файл ex1.py находится в
каталоге app:

Тогда, чтобы
обратиться к файлу my_file.txt путь можно
записать так:

«my_file.txt»

или

«d:\app\my_file.txt»

или так:

«d:/app/my_file.txt»

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

Теперь,
предположим, мы хотим обратиться к файлу img.txt. Это можно
сделать так:

«images/img.txt»

или так:

«d:/app/images/img.txt»

Для доступа к out.txt пути будут
записаны так:

«../out.txt»

«d:/out.txt»

Обратите
внимание, здесь две точки означают переход к родительскому каталогу, то есть,
выход из каталога app на один уровень вверх.

И, наконец, для
доступа к файлу prt.dat пути запишутся так:

«../parent/prt.dat»

«d:/ parent/prt.dat»

Вот так следует
прописывать пути к файлам. В нашем случае мы имеем текстовый файл «myfile.txt», который
находится в том же каталоге, что и программа ex1.py, поэтому путь
можно записать просто указав имя файла:

file = open("myfile.txt")

В результате
переменная file будет ссылаться
на файловый объект, через который и происходит работа с файлами. Если указать
неверный путь, например, так:

file = open("myfile2.txt")

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

try:
    file = open("myfile2.txt")
except FileNotFoundError:
    print("Невозможно открыть файл")

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

mode = «r»

Если нам нужно
поменять режим доступа к файлу, например, открыть его на запись, то это явно
указывается вторым параметром функции open:

file = open("out.txt", "w")

В Python имеются
следующие режимы доступа:

Здесь мы имеем
три основных режима доступа: на чтение, запись и добавление. И еще три
возможных расширения этих режимов, например,

• ‘rt’ – чтение в
  текстовом режиме;

• ‘wb’ – запись в
  бинарном режиме;

• ‘a+’ – дозапись
  или чтение данных из файла.

Чтение информации из файла

В чем отличие
текстового режима от бинарного мы поговорим позже, а сейчас откроем файл на
чтение в текстовом режиме:

file = open("myfile.txt")

и прочитаем его
содержимое с помощью метода read:

В результате, получим
строку, в которой будет находиться прочитанное содержимое. Действительно, в
этом файле находятся эти строчки из поэмы Пушкина А.С. «Медный всадник». И
здесь есть один тонкий момент. Наш текстовый файл имеет кодировку Windows-1251 и эта
кодировка используется по умолчанию в функции read. Но, если
изменить кодировку файла, например, на популярную UTF-8, то после
запуска программы увидим в консоли вот такую белиберду. Как это можно
исправить, не меняя кодировки самого файла? Для этого следует воспользоваться
именованным параметром encoding и записать метод open вот так:

file = open("myfile.txt", encoding="utf-8" )

Теперь все будет
работать корректно. Далее, в методе read мы можем
указать некий числовой аргумент, например,

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

print( file.read(2) )
print( file.read(2) )

то увидим, что
при следующем вызове метод read продолжил читать следующие два символа.
Почему так произошло? Дело в том, что у файлового объекта, на который ссылается
переменная file, имеется
внутренний указатель позиции (file position), который
показывает с какого места производить считывание информации.

Когда мы
вызываем метод read(2) эта позиция автоматически сдвигается от начала
файла на два символа, т.к. мы именно столько считываем. И при повторном вызове read(2) считывание
продолжается, т.е. берутся следующие два символа. Соответственно, позиция файла
сдвигается дальше. И так, пока не дойдем до конца.

Но мы в Python можем управлять
этой файловой позицией с помощью метода

seek(offset[, from_what])

Например, вот такая запись:

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

print( file.read(2) )
file.seek(0)
print( file.read(2) )

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

pos = file.tell()
print( pos )

Следующий
полезный метод – это readline позволяет построчно считывать
информацию из текстового файла:

s = file.readline()
print( s )

Здесь концом
строки считается символ переноса ‘n’, либо конец файла. Причем, этот
символ переноса строки будет также присутствовать в строке. Мы в этом можем
убедиться, вызвав дважды эту функцию:

    print( file.readline() )
    print( file.readline() )

Здесь в консоли
строчки будут разделены пустой строкой. Это как раз из-за того, что один
перенос идет из прочитанной строки, а второй добавляется самой функцией print. Поэтому, если
их записать вот так:

    print( file.readline(), end="" )
    print( file.readline(), end="" )

то вывод будет
построчным с одним переносом.

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

    for line in file:
        print( line, end="" )

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

Или же, все
строчки можно прочитать методом

и тогда
переменная s будет ссылаться
на упорядоченный список с этими строками:

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

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

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

try:
    file = open("myfile.txt")
 
    try:
        s = file.readlines()
        print( s )
    finally:
        file.close()
 
except FileNotFoundError:
    print("Невозможно открыть файл")

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

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

try:
    with open("myfile.txt", "r") as file:      # file = open("myfile.txt")
        s = file.readlines()
        print( s )
 
except FileNotFoundError:
    print("Невозможно открыть файл")

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

finally:
    print(file.closed)

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

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

Запись информации в файл

Теперь давайте
посмотрим, как происходит запись информации в файл. Во-первых, нам нужно
открыть файл на запись, например, так:

file = open("out.txt", "w")

и далее вызвать
метод write:

file.write("Hello World!")

В результате у
нас будет создан файл out.txt со строкой «Hello World!». Причем, этот
файл будет располагаться в том же каталоге, что и файл с текстом программы на Python.

Далее сделаем
такую операцию: запишем метод write следующим
образом:

И снова выполним
эту программу. Смотрите, в нашем файле out.txt прежнее
содержимое исчезло и появилось новое – строка «Hello». То есть,
когда мы открываем файл на запись в режимах

w, wt, wb,

то прежнее
содержимое файла удаляется. Вот этот момент следует всегда помнить.

Теперь
посмотрим, что будет, если вызвать метод write несколько раз
подряд:

    file.write("Hello1")
    file.write("Hello2")
    file.write("Hello3")

Смотрите, у нас
в файле появились эти строчки друг за другом. То есть, здесь как и со
считыванием: объект file записывает информацию, начиная с текущей файловой
позиции, и автоматически перемещает ее при выполнении метода write.

Если мы хотим
записать эти строчки в файл каждую с новой строки, то в конце каждой пропишем
символ переноса строки:

   file.write("Hello1n")
   file.write("Hello2n")
   file.write("Hello3n")

Далее, для
дозаписи информации в файл, то есть, записи с сохранением предыдущего
содержимого, файл следует открыть в режиме ‘a’:

file = open("out.txt", "a")

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

то возникнет
ошибка доступа. Если же мы хотим и записывать и считывать информацию, то можно воспользоваться
режимом a+:

file = open("out.txt", "a+")

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

   file.seek(0)
   print( file.read() )

А вот запись
данных всегда осуществляется в конец файла.

Следующий
полезный метод для записи информации – это writelines:

file.writelines(["Hello1n", "Hello2n"])

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

Чтение и запись в бинарном режиме доступа

Что такое
бинарный режим доступа? Это когда данные из файла считываются один в один без
какой-либо обработки. Обычно это используется для сохранения и считывания
объектов. Давайте предположим, что нужно сохранить в файл вот такой список:

books = [
("Евгений Онегин", "Пушкин А.С.", 200),
("Муму", "Тургенев И.С.", 250),
("Мастер и Маргарита", "Булгаков М.А.", 500),
("Мертвые души", "Гоголь Н.В.", 190)
]

Откроем файл на
запись в бинарном режиме:

file = open("out.bin", "wb")

Далее, для работы
с бинарными данными подключим специальный встроенный модуль pickle:

И вызовем него
метод dump:

Все, мы
сохранили этот объект в файл. Теперь прочитаем эти данные. Откроем файл на
чтение в бинарном режиме:

file = open("out.bin", "rb")

и далее вызовем
метод load модуля pickle:

Все, теперь
переменная bs ссылается на
эквивалентный список:

Аналогичным
образом можно записывать и считывать сразу несколько объектов. Например, так:

import pickle
 
book1 = ["Евгений Онегин", "Пушкин А.С.", 200]
book2 = ["Муму", "Тургенев И.С.", 250]
book3 = ["Мастер и Маргарита", "Булгаков М.А.", 500]
book4 = ["Мертвые души", "Гоголь Н.В.", 190]
 
try:
    file = open("out.bin", "wb")
 
    try:
        pickle.dump(book1, file)
        pickle.dump(book2, file)
        pickle.dump(book3, file)
        pickle.dump(book4, file)
 
    finally:
        file.close()
 
except FileNotFoundError:
    print("Невозможно открыть файл")

А, затем,
считывание в том же порядке:

    file = open("out.bin", "rb")
    b1 = pickle.load(file)
    b2 = pickle.load(file)
    b3 = pickle.load(file)
    b4 = pickle.load(file)
 
    print( b1, b2, b3, b4, sep="n" )

Вот так в Python выполняется
запись и считывание данных из файла.

Задания для самоподготовки

1. Выполните
считывание данных из текстового файла через символ и записи прочитанных данных
в другой текстовый файл. Прочитывайте так не более 100 символов.

2. Пользователь
вводит предложение с клавиатуры. Разбейте это предложение по словам (считать,
что слова разделены пробелом) и сохраните их в столбец в файл.

3. Пусть имеется
словарь:

d = {«house»:
«дом», «car»: «машина»,

    
«tree»:
«дерево», «road»: «дорога»,

     «river»:
«река»}

Необходимо
каждый элемент этого словаря сохранить в бинарном файле как объект. Затем,
прочитать этот файл и вывести считанные объекты в консоль.

Введение в тему

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

 Файлы python

Файл — это определенное количество информации, имеющее имя и хранящееся в долговременной памяти. Другими словами, это набор данных, которому дали имя и где-то сохранили.

В Питоне файлы делятся на две разновидности:

— Текстовые

— Бинарные

Текстовые файлы

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

Бинарные файлы

Бинарные файлы содержат набор нулей и единиц. Таким образом можно хранить любую информацию: изображения, аудио, видео и даже текст.

Работа с файлами состоит из следующих шагов:

Файл надо открыть

Произвести необходимые операции (запись или чтение)

Закрыть файл

Открытие файла

Метод open

И так, если Вы хотите произвести какие-либо операции с файлом, сперва придётся его открыть. Для этой цели в языке Пайтон есть встроенная функция open(). Используя эту функцию, можно создать на основе любого языка файла объект Python.

Где,

• name- имя файла, который Вы открываете
• mode- режим открытия. Если не указать этот параметр, файл будет открыт в режиме «только чтение». Режимы открытия файла могут быть следующими:

Файловый объект имеет несколько атрибутов, предоставляющих информацию о файле:

Пример

Для начала необходимо сохранить в новый файл «test.txt» какой-то текст. Этот файл должен быть расположен в рабочей папке.

Применим следующий код для открытия данного файла:

file = open('test.txt', 'r')  # открыть файл из рабочей папки в режиме чтения, относительный путь
file_2 = open('C:\Users\Dushenko\Desktop\test.txt', 'r')  # открыть файл из любого каталога

  

В переменных file и file_2 хранятся ссылки на объекты с открытыми файлами.

Теперь посмотрим содержимое файла и информацию о нём:

file = open('C:\Users\Dushenko\Desktop\test.txt', 'r')
print(*file)
print(file)
file.close()
# Вывод:

Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.

<_io.TextIOWrapper name='C:\Users\Dushenko\Desktop\test.txt' mode='r' encoding='cp1251'>

  

Закрытие файла

Метод close

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

Python сам закроет файл, если присвоить объект другому файлу.

Так же можно использовать метод close().

file = open('C:\Users\Dushenko\Desktop\test.txt', 'r')  # открыть файл из любого каталога
print(*file)
file.close()
  

Инструкция with

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

Конструкция with называется менеджер контекста.

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

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

with open('C:\Users\Dushenko\Desktop\test.txt') as file:
    # какие-то операции
  

Чтение и запись файлов в python

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

Функция read

Применяя функцию read() Вы можете прочесть информацию из файл, который был открыт в режиме чтения (r):

Где,

• file- объект файла
• size- количество символов, которые Вы хотите получить. Когда этот параметр не указан, файл читается от начала до конца.

Вот как это выглядит:

file = open('C:\Users\Dushenko\Desktop\test.txt', 'r')
print(file.read(17))
file.close()
# Вывод:

Lorem ipsum dolor

  

Если повторно вызвать функцию read(), то чтение начнется с 18-го символа.

file = open('C:\Users\Dushenko\Desktop\test.txt', 'r')
print(file.read(17))
print(file.read(17))
file.close()
# Вывод:

Lorem ipsum dolor

sit amet, consec
  

Функция readline

Если файл большой и Вы прочитаете его целиком, он заполнит оперативную память и может возникнуть её дефицит. Чтобы этого избежать лучше читать файл построчно. Для этого в Python есть метод readline(), который обеспечивает доступ к любой строке файла.

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

file = open('C:\Users\Dushenko\Desktop\test.txt', 'r')
print(file.readline()) # Читает одну строку
print(file.readlines(2)) # Читает вторую строку
print(file.readlines()) # Читает все оставшиеся строки
file.close()
# Вывод:

Lorem ipsum dolor sit amet,

 

['consectetur adipiscing elit,n']

['sed do eiusmod tempor incididuntn', 'ut labore et dolore magna aliqua.']

  

Есть и другие способы.

Циклом for:

with open('C:\Users\Dushenko\Desktop\test.txt', 'r') as file:
    # итерация по строкам
    for line in file:
        print(line.strip())
# Вывод:

Lorem ipsum dolor sit amet,

consectetur adipiscing elit,

sed do eiusmod tempor incididunt

ut labore et dolore magna aliqua.

  

Функцией next():

with open('C:\Users\Dushenko\Desktop\test.txt', 'r') as file:
    print(next(file))
    print(next(file))
    print(next(file))
    print(next(file))
# Вывод:

Lorem ipsum dolor sit amet,

 

consectetur adipiscing elit,

 

sed do eiusmod tempor incididunt

 

ut labore et dolore magna aliqua.

  

Циклом while:

with open('C:\Users\Dushenko\Desktop\test.txt', 'r') as file:
    line = file.readline(30)
    while line:
        line = line.rstrip('n')
        print(line)
        line = file.readline(30) # Читаем файл кусками по 30 байт
# Вывод:

Lorem ipsum dolor sit amet,

consectetur adipiscing elit,

sed do eiusmod tempor incididu

nt

ut labore et dolore magna aliq

ua.
  

Функция write

Если Вам необходимо записать что-то в файл, надо совершить следующие шаги:

— открыть файл в режиме записи;

— использовать функцию write();

— закрыть файл.

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

Вот как это применять:

file = open('C:\Users\Dushenko\Desktop\test.txt', 'r')
print(file.read())
file.close()
file = open('C:\Users\Dushenko\Desktop\test.txt', 'w')
print(file.write('Hello!'))
file.close()
file = open('C:\Users\Dushenko\Desktop\test.txt', 'r')
print(file.read())
file.close()
# Вывод:

Lorem ipsum dolor sit amet,

consectetur adipiscing elit,

sed do eiusmod tempor incididunt

ut labore et dolore magna aliqua.

6

Hello!

  

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

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

Функция rename

Для того, чтобы поменять имя файла, Вам придётся применить функцию rename() из модуля os стандартной библиотеки Python.

Первым параметром нужно передать имя файла, который надо передать, а вторым – новое имя:

import os

file = open('C:\Users\Dushenko\Desktop\test.txt', 'r')
print(file.name)
file.close()
os.rename(file.name,'C:\Users\Dushenko\Desktop\test_new.txt')
file = open('C:\Users\Dushenko\Desktop\test_new.txt', 'r')
print(file.name)
file.close()
# Вывод:

C:UsersDushenkoDesktoptest.txt

C:UsersDushenkoDesktoptest_new.txt
  

Текущая позиция в файлах python

Если хотите узнать текущую позицию в файле, используйте метод tell(). Чтоб изменить позицию – метод seek().

Попробуем:

file = open('C:\Users\Dushenko\Desktop\test.txt', 'r')
print(file.readline())
print(file.tell())
file.seek(59)
print(file.readline())
file.close()
# Вывод:

Lorem ipsum dolor sit amet,

 

29

sed do eiusmod tempor incididunt