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

ОТКРЫТИЕ ФАЙЛА

Для каждого файла, с которым необходимо производить операции ввода-вывода, нужно связать специальный объект – поток. Открытие файла осуществляется функцией open, которой нужно передать два параметра. Первый параметр (можно также использовать именованный параметр file) имеет значение типа str, в котором записано имя открываемого файла. Второй параметр (можно также использовать именованный параметр mode) —это значение типа str, которое равно “r”, если файл открывается для чтения данных (read), “w”, если на запись (write), при этом содержимое файла очищается, и “a” — для добавления данных в конец файла (append). Если второй параметр не задан, то считается, что файл открывается в режиме чтения.

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

input = open('input.txt', 'r')

output = open('output.txt', 'w')

ЧТЕНИЕ ДАННЫХ ИЗ ФАЙЛА

Для файла, открытого на чтение данных, можно вызывать следующие методы, позволяющие читать данные из файла.
Метод readline() считывает одну строку из файла (до символа конца строки ‘\n’, возвращается считанная строка вместе с символом ‘\n’. Если считывание не было успешно (достигнут конец файла), то возвращается пустая строка. Для удаления символа ‘\n’ из конца файла удобно использовать метод строки rstrip(). Например:

s = s.rstrip().

Метод readlines() считывает все строки из файла и возвращает список из всех считанных строк (одна строка — один элемент списка). При этом символы ‘\n’ остаются в концах строк.

Метод read() считывает все содержимое из файла и возвращает строку, которая может содержать символы ‘\n’. Если методу read передать целочисленный параметр, то будет считано не более заданного количества символов. Например, считывать файл побайтово можно при помощи метода read(1).

ВЫВОД ДАННЫХ В ФАЙЛ

Данные выводятся в файл при помощи метода write, которому в качестве параметра передается одна строка. Этот метод не выводит символ конца строки ‘\n’ (как это делает функция print при стандартном выводе), поэтому для перехода на новую строку в файле необходимо явно вывести символ ‘\n’.

Также можно выводить данные в файл при помощи функции print, если передать ей еще один именованный параметр file, равный ссылке на открытый файл. Например:

output = open('output.txt', 'w')

print(a, b, c, file=output)

ЗАКРЫТИЕ ФАЙЛА

После окончания работы с файлом необходимо закрыть его при помощи метода close().

Пример
Следующая программа считывает все содержимое файла input.txt, записывает его в переменную s, а затем выводит ее в файл output.txt.

input = open('input.txt', 'r')

output = open('output.txt', 'w')

s = input.read()

output.write(s)

input.close()

output.close()

А вот аналогичная программа, но читающая данные посимвольно:

input = open('input.txt', 'r')

output = open('output.txt', 'w')

c = input.read(1)

while len(c) > 0:

output.write(c)

c = input.read(1)

input.close()

output.close()

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

Отбрасывание незначащих символов

Для отбрасывания пробельных символов, табуляции и символа перевода строки в начале и конце строки существуют метод strip(), а для отрбасывания лишних символов на конце — rstrip().

>>> s=' \tspam \n'

>>> s.strip() # и в начале, и в конце

'spam'

>>> s.rstrip() # в конце

' \tspam'

>>> s.lstrip() # в начале

'spam \n'

Регистр символов в строке

s.upper() # к верхнему

s.lower() # к нижнему

s.title() # первый символ каждого слова к верхнему

s.capitalize() # первый символ строки к верхнему

s.isupper() # проверить находиться ли строка в верхнем регистре s.islower() # проверить находиться ли строка в нижнем регистре

Генераторы списков в Python

Для создания списка, заполненного одинаковыми элементами, можно использовать оператор повторения списка, например:

A = [0] * n

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

[выражение for переменная in список]

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

Вот несколько примеров использования генераторов.

Создать список, состоящий из n нулей можно и при помощи генератора:

A = [0 for i in range(n)]

Создать список, заполненный квадратами целых чисел можно так:

A = [i ** 2 for i in range(n)]

Если нужно заполнить список квадратами чисел от 1 до n, то можно изменить параметры функции range на range(1, n + 1):

A = [i ** 2 for i in range(1, n + 1)]

Вот так можно получить список, заполненный случайными числами от 1 до 9 (используя функцию randint из модуля random):

A = [randint(1, 9) for i in range(n)]

А в этом примере список будет состоять из строк, считанных со стандартного ввода: сначала нужно ввести число элементов списка (это значение будет использовано в качестве аргумента функции range), потом — заданное количество строк:

A = [input() for i in range(int(input()))]

Двумерные массивы в Python

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

A = [[1, 2, 3], [4, 5, 6]]

Здесь первая строка списка A[0] является списком из чисел [1, 2, 3]. То есть A[0][0] == 1, значение A[0][1] == 2, A[0][2] == 3, A[1][0] == 4, A[1][1] == 5, A[1][2] == 6.

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

for i in range(len(A)):
for j in range(len(A[i]):
print(A[i][j], end=' ')
print()

То же самое, но циклы не по индексу, а по значениям списка:

for row in A:
for elem in row:
print(elem, end=' ')
print()

Естественно для вывода одной строки можно воспользоваться методом join:

for row in A:
print(' '.join(list(map(str, row))))

Используем два вложенных цикла для подсчета суммы всех чисел в списке:

S = 0
for i in range(len(A)):
for j in range(len(A[i])):
S += A[i][j]

Или то же самое с циклом не по индексу, а по значениям строк:

S = 0
for row in A:
for elem in row:
S += elem

СОЗДАНИЕ ВЛОЖЕННЫХ СПИСКОВ

Пусть даны два числа: количество строк n и количество столбцов m. Необходимо создать список размером n×m, заполненный нулями.
Очевидное решение оказывается неверным:

# Неправильно
A = [[0] * m] * n

В этом легко убедиться, если присвоить элементу A[0][0] значение 1, а потом вывести значение другого элемента A[1][0] — оно тоже будет равно 1! Дело в том, что [0] * m возвращает ccылку на список из m нулей. Но последующее повторение этого элемента создает список из n элементов, которые являются ссылкой на один и тот же список (точно так же, как выполнение операции B = A для списков не создает новый список), поэтому все строки результирующего списка на самом деле являются одной и той же строкой.

Таким образом, двумерный список нельзя создавать при помощи операции повторения одной строки. Что же делать?
Первый способ: сначала создадим список из n элементов (для начала просто из n нулей). Затем сделаем каждый элемент списка ссылкой на другой одномерный список из m элементов:

A = [0] * n
for i in range(n):
A[i] = [0] * m

Другой (но похожий) способ: создать пустой список, потом n раз добавить в него новый элемент, являющийся списком-строкой:

A = []
for i in range(n):
A.append([0] * m)

Но еще проще воспользоваться генератором: создать список из n элементов, каждый из которых будет списком, состоящих из m нулей:

A = [[0] * m for i in range(n)]

В этом случае каждый элемент создается независимо от остальных (заново конструируется список [0] * m для заполнения очередного элемента списка), а не копируются ссылки на один и тот же список.

ВВОД ДВУМЕРНОГО МАССИВА

Пусть программа получает на вход двумерный массив, в виде n строк, каждая из которых содержит m чисел, разделенных пробелами. Как их считать? Например, так:

A = []
for i in range(n):
A.append(list(map(int, input().split())))

Или без использования сложных вложенных вызовов функций:

A = []
for i in range(n):
row = input().split()
for i in range(len(row)):
row[i] = int(row[i])
A.append(row)

Можно сделать то же самое и при помощи генератора:

A = [list(map(int, input().split())) for i in range(n)]

ПРИМЕР ОБРАБОТКИ ДВУМЕРНОГО МАССИВА

Пусть дан квадратный массив из n строк и n столбцов. Необходимо элементам, находящимся на главной диагонали, проходящей из левого верхнего угла в правый нижний (то есть тем элементам A[i][j], для которых ij) присвоить значение 1, элементам, находящимся выше главной диагонали – значение 0, элементам, находящимся ниже главной диагонали – значение 2. То есть получить такой массив (пример для n = 4):

1 0 0 0

2 1 0 0

2 2 1 0

2 2 2 1

Рассмотрим несколько способов решения этой задачи. Элементы, которые лежат выше главной диагонали – это элементы A[i][j], для которых i<j, а для элементов ниже главной диагонали i>j. Таким образом, мы можем сравнивать значения i и j и по ним определять значение A[i][j]. Получаем следующий алгоритм:

for i in range(n):
for j in range(n):
if i < j:
A[i][j] = 0
elif i > j:
A[i][j] = 2
else:
A[i][j] = 1

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

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

for i in range(n):
A[i][i] = 1

Затем заполним значением 0 все элементы выше главной диагонали, для чего нам понадобится в каждой из строк с номером i присвоить значение элементам A[i][j] для j=i+1, …, n-1. Здесь нам понадобятся вложенные циклы:

for i in range(n):
for j in range(i + 1, n):
A[i][j] = 0

Аналогично присваиваем значение 2 элементам A[i][j] для j=0, …, i-1:

for i in range(n):
for j in range(0, i):
A[i][j] = 2

Можно также внешние циклы объединить в один и получить еще одно, более компактное решение:

for i in range(n):
for j in range(0, i):
A[i][j] = 2
A[i][i] = 1
for j in range(i + 1, n):
A[i][j] = 0

А вот такое решение использует операцию повторения списков для построения очередной строки списка. i-я строка списка состоит из i чисел 2, затем идет одно число 1, затем идет n-i-1 число 0:

for i in range(n):

A[i] = [2] * i + [1] + [0] * (n - i - 1)

А можно заменить цикл на генератор:

A = [[2] * i + [1] + [0] * (n - i - 1) for i in range(n)]