Считываем числовые данные из файла на Python
В данной статье речь пойдет о простой на первой взгляд задаче — считывании числовых данных из текстовых файлов на Python. В сети можно найти десятки способов решения этой задачи, однако эти алгоритмы оказываются малоэффективными при работе с большим объемом данных. В данной статье будут разобраны самые популярные методики, а также произведено сравнение их скорости работы.
Введение
Когда я только начинал изучать Python, главным помощником в работе для меня, как наверное и для большинства программистов, был Stack Overflow. Я почерпнул оттуда много полезной информации, в том числе и о работе с файлами. Однако даже такая тривиальная задача, как оказалось, имеет несколько различных решений, отличающихся друг от друга простотой реализации и скоростью работы.
Большинство предложенных методов предполагают чтение файла построчно с дальнейшим разбиением на блоки и их преобразованием из строкового типа в числовой, поскольку Python в отличии от C/C++ работает с файлами как с массивом строк. Выполнить последовательное чтение данных в массив без преобразования типов, как это можно сделать в C/C++, стандартными средствами языка невозможно (насколько мне известно), и это существенно увеличивает время работы программы при обработке больших объемов данных.
Способы чтения данных из файла
Как уже было сказано выше, файлы в Python представляют собой массив строк, поэтому все найденные методы можно символически поделить на два типа в зависимости от используемого подхода:
- построчное считывание с разбиением и преобразованием типов
- использование библиотек, которые средствами других языков (например, C/C++) считывают файл и передают полученные данные интерпретатору Python
Ниже представлена подборка самых популярных методов чтения числовых данных на Python, отмеченных сообществом Stack Overflow как «best answer».
Способ 1 — построчное считывание с преобразованием
Самый популярный и простой вариант. Заключается в построчном чтении с разбиением полученной строки на блоки, которые затем преобразуются к необходимому типу данных (в данном случае float) и добавляются к заранее созданному списку.
data = [] with open("data.txt") as f: for line in f: data.append([float(x) for x in line.split()])
Способ 2 — преобразование при помощи map
Способ аналогичен предыдущему, за исключением того, что преобразованием данных из строкового формата в числовой занимается функция map.
file = open("data.txt", "r") data = [map(float, line.split("\t")) for line in file]
Способ 3 — с использованием регулярного выражения
Данный способ можно назвать стрельбой из пушки по воробьям, однако у него все же есть свои плюсы: если данные в файле расположены хаотично и отсутствует постоянная структура, то функции split невозможно задать конкретный разделитель и для решения задачи можно использовать регулярное выражение, которое найдет в строке все числа, несмотря на их расположение и наличие разделителей.
import re file = open("data.txt") values = file.read().split("\n") data = [] for key in values: value = re.findall(r"[-+]?\d*\.\d+|\d+", key) if value != []: data.append(value)
Способ 4 — с использованием CSV Reader
Если данные записаны в виде матрицы с постоянными разделителями, то выполнить их чтение можно при помощи модуля CSV Reader, указав в качестве параметра значение разделителя.
import csv with open("data.txt") as f: data = [map(float, row) for row in csv.reader(f, delimiter='\t')]
Способ 5 — Numpy loadtxt
Библиотека Numpy предоставляет широкий набор модулей и функций для обработки числовых данных, в том числе и для чтения массивов из файлов. Одна из реализаций возможна с помощью функции loadtxt, результат работы которой будет записан в numpy.array.
import numpy as np data = np.loadtxt("data.txt", delimiter='\t', dtype=np.float)
Способ 6 — Numpy genfromtxt
Данный способ не сильно отличается от предыдущего, за исключением того, что genfromtxt предоставляет более широкий набор входных параметров: указание различных типов данных для каждого из столбцов, передача ключей для создания ассоциативного массива и так далее.
import numpy as np data = np.genfromtxt("data.txt", delimiter='\t', dtype=np.float)
Способ 7 — Pandas read_csv
Pandas — мощная библиотека для обработки данных на Python. В данном примере рассматривается только чтение данных, но её возможности этим не ограничены. Метод read_csv предоставляет широкий набор входных параметров, а также показывается высокую скорость работы даже при работе с большими объемами данных.
import pandas as pd data = pd.read_csv("data.txt", sep="\t", header=None)
Методы тестирования скорости чтения
Для тестирования скорости чтения числовых данных были сгенерированы 7 тестовых файлов, содержащих 5 столбцов и 10, 100, 1 000, 10 000, 100 000, 1 000 000 и 10 000 000 строк случайных чисел формата float. Размер самого большого файла составил 742 Мб.
Для измерения времени работы программы использовалась функция time. Существует мнение, что измерять с её помощью время работы некорректно. Однако в данном случае меня интересовало работа с большими объемами данных, когда время работы программы составляло несколько десятков секунд. В таком случае отклонение в полсекунды вносило погрешность менее 1%.
Сравнение с компилируемыми языками программирования
Программы, созданные на компилируемых языках программирования, работают быстрее, чем их аналоги, написанные на интерпретируемых языках. Мне было интересно сравнить скорость чтения каждого метода с Fortran и C++ — самыми популярными языками в научном программировании, с которыми мне также приходится иметь дело в силу специфики моей работы.
Fortran
Несмотря на то, что Fortran считается устаревшим языком, он все еще очень популярен в научном программировании благодаря простоте написания кода, скорости обмена данных и обширном количестве библиотек, созданных за последние полвека.
Например, считать числовую матрицу из файла можно всего за 3 строчки кода при условии корректности входных данных.
real, dimension (5, 1000) :: data open (1, file='data.txt') read(1, *) data
C++
Дискуссии о том, что лучше: Fortran или C++ ведутся уже давно, даже среди авторов EasyCoding этот спор возникал несколько раз, поэтому мне было еще интересней протестировать чтение матриц на данном языке.
ifstream file(«data.txt»); int count = 100000; float** data = new float*[count]; for(int i = 0; i
Результаты тестирования
В ходе эксперимента были протестированы 7 программ на языке Python и по одной на Fortran и C++, код которых представлен выше. Запуск программ осуществлялся на компьютере с Intel Core i5 2.7 GHz и 8 Гб оперативной памяти.
Для запуска программ использовались следующие интерпретаторы и компиляторы:
- Python 3.5.2
- GNU Fortran (GCC) 6.1.0
- g++ 4.2.1
Для каждой программы проводилась серия испытаний и измерялось время работы, после чего записывался результат в виде среднего арифметического полученных данных. В таблице ниже жирным в каждой строке выделено наименьшее время работы в зависимости от способа чтения и размера входного файла.
| Число строк | Способ | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | Fortran | C++ | |
| 10 | 0.048 | 0.048 | 0.045 | 0.044 | 0.173 | 0.216 | 0.479 | 0.005 | 0.005 |
| 100 | 0.053 | 0.052 | 0.05 | 0.048 | 0.185 | 0.223 | 0.511 | 0.007 | 0.006 |
| 1 000 | 0.056 | 0.053 | 0.053 | 0.052 | 0.187 | 0.233 | 0.6 | 0.01 | 0.01 |
| 10 000 | 0.085 | 0.076 | 0.096 | 0.083 | 0.305 | 0.292 | 0.636 | 0.032 | 0.041 |
| 100 000 | 0.414 | 0.403 | 0.561 | 0.482 | 1.537 | 0.874 | 0.796 | 0.244 | 0.363 |
| 1 000 000 | 3.835 | 4.502 | 6.086 | 5.276 | 13.607 | 6.754 | 1.763 | 2.584 | 3.662 |
| 10 000 000 | 47.931 | 156.944 | 137.398 | 144.75 | 162.724 | 85.642 | 13.632 | 25.652 | 36.622 |
Итог
В ходе данного исследования были протестированы 7 самых популярных варианта чтения числовых матриц на языке Python, предложенными пользователями сайта Stack Overflow и отмеченными сообществом как «верный ответ». Как видно из таблицы с результатами, скорость работы программ не сильно отличается при использовании способов 1-4 на небольших объемах данных. Это связано с тем, что интерпретатор не тратит время на инициализацию сторонней библиотеки, как в методах 5-7.
Однако при увеличении объема входных данных лучше всех себя показал метод 7 с использованием библиотеки Pandas, который даже обогнал по скорости чтения данных языки C++ и Fortran.
Также из результатов теста можно видеть, что программа на Fortran справилась с чтением данных быстрей аналога на C++, что еще раз доказывает его превосходство над самым популярным языком программирования в мире.
10 commentaries to post
Наконец, нашел, что искал. Способ 6 — Numpy genfromtxt, который предоставляет более широкий набор входных параметров: указание различных типов данных для каждого из столбцов, передача ключей для создания ассоциативного массива и так далее.
Спасибо. Сэкономили время на поиск единственного, что нужно для моих вычислений по таблице «тексты-слова»…
ошибка в таблице ! 0.044 не меньше чем 0.005 а больше почти в 9 раз!
nightflash :
Нет ошибки. Автор сравнивал скорости Python решений.
С++, который обгонит всё перечисленное:
FILE* f = fopen(«data.txt», «rb») int count = 10000; float** data = new float*[count]; for(int i = 0; i < count; ++i)
Причем не особо кошерная реализация. Но соответствует предоставленному коду.
Кошерная реализация это:
fread(data, sizeof(float) * 5 * count, f);
Основы работы с файлами в Python
Введение в работу с файлами в Python с помощью встроенной функциональности языка.
Михаил Свинцов
автор курса «Full-stack веб-разработчик на Python»
Взаимодействие с файловой системой позволяет хранить информацию, полученную в результате работы программы. Михаил Свинцов из SkillFactory расскажет о базовой функциональности языка программирования Python для работы с файлами.
Встроенные средства Python
Основа для работы с файлами — built-in функция open()
open(file, mode="rt")
Эта функция имеет два аргумента. Аргумент file принимает строку, в которой содержится путь к файлу. Второй аргумент, mode , позволяет указать режим, в котором необходимо работать с файлом. По умолчанию этот аргумент принимает значение «rt», с которым, и с некоторыми другими, можно ознакомиться в таблице ниже
Эти режимы могут быть скомбинированы. Например, «rb» открывает двоичный файл для чтения. Комбинируя «r+» или «w+» можно добиться открытия файла в режиме и чтения, и записи одновременно с одним отличием — первый режим вызовет исключение, если файла не существует, а работа во втором режиме в таком случае создаст его.
Начать саму работу с файлом можно с помощью объекта класса io.TextIOWrapper , который возвращается функцией open() . У этого объекта есть несколько атрибутов, через которые можно получить информацию
- name — название файла;
- mode — режим, в котором этот файл открыт;
- closed — возвращает True , если файл был закрыт.
По завершении работы с файлом его необходимо закрыть при помощи метода close()
f = open("examp.le", "w") // работа с файлом f.close()
Однако более pythonic way стиль работы с файлом встроенными средствами заключается в использовании конструкции with .. as .. , которая работает как менеджер создания контекста. Написанный выше пример можно переписать с ее помощью
with open("examp.le", "w") as f: // работа с файлом
Главное отличие заключается в том, что python самостоятельно закрывает файл, и разработчику нет необходимости помнить об этом. И бонусом к этому не будут вызваны исключения при открытии файла (например, если файл не существует).
Чтение из файла
При открытии файла в режимах, допускающих чтение, можно использовать несколько подходов.
Работа со строками в Python. Готовимся к собеседованию: вспоминаем азы
Для начала можно прочитать файл целиком и все данные, находящиеся в нем, записать в одну строку.
with open("examp.le", "r") as f: text = f.read()
Используя эту функцию с целочисленным аргументом, можно прочитать определенное количество символов.
with open("examp.le", "r") as f: part = f.read(16)
При этом будут получены только первые 16 символов текста. Важно понимать, что при применении этой функции несколько раз подряд будет считываться часть за частью этого текста — виртуальный курсор будет сдвигаться на считанную часть текста. Его можно сдвинуть на определенную позицию, при необходимости воспользовавшись методом seek() .
with open("examp.le", "r") as f: # 'Hello, world!' first_part = f.read(8) # 'Hello, w' f.seek(4) second_part = f.read(8) # 'o, world'
Другой способ заключается в считывании файла построчно. Метод readline() считывает строку и, также как и с методом read() , сдвигает курсор — только теперь уже на целую строку. Применение этого метода несколько раз будет приводить к считыванию нескольких строк. Схожий с этим способом, другой метод позволяет прочитать файл целиком, но по строкам, записав их в список. Этот список можно использовать, например, в качестве итерируемого объекта в цикле.
with open("examp.le", "r") as f: for line in f.readlines(): print(line)
Однако и здесь существует более pythonic way. Он заключается в том, что сам объект io.TextIOWrapper имеет итератор, возвращающий строку за строкой. Благодаря этому нет необходимости считывать файл целиком, сохраняя его в список, а можно динамически по строкам считывать файл. И делать это лаконично.
with open("examp.le", "r") as f: for line in f: print(line)
Запись в файл
Функциональность внесения данных в файл не зависит от режима — добавление данных или перезаписывание файла. В выполнении этой операции также существует несколько подходов.
Самый простой и логичный — использование функции write()
with open("examp.le", "w") as f: f.write(some_string_data)
Важно, что в качестве аргумента функции могут быть переданы только строки. Если необходимо записать другого рода информацию, то ее необходимо явно привести к строковому типу, используя методы __str__(self) для объектов или форматированные строки.
Есть возможность записать в файл большой объем данных, если он может быть представлен в виде списка строк.
with open("examp.le", "w") as f: f.writelines(list_of_strings)
Здесь есть еще один нюанс, связанный с тем, что функции write() и writelines() автоматически не ставят символ переноса строки, и это разработчику нужно контролировать самостоятельно.
Существует еще один, менее известный, способ, но, возможно, самый удобный из представленных. И как бы не было странно, он заключается в использовании функции print() . Сначала это утверждение может показаться странным, потому что общеизвестно, что с помощью нее происходит вывод в консоль. И это правда. Но если передать в необязательный аргумент file объект типа io.TextIOWrapper , каким и является объект файла, с которым мы работаем, то поток вывода функции print() перенаправляется из консоли в файл.
with open("examp.le", "w") as f: print(some_data, file=f)
Сила такого подхода заключается в том, что в print() можно передавать не обязательно строковые аргументы — при необходимости функция сама их преобразует к строковому типу.
На этом знакомство с базовой функциональностью работы с файлами можно закончить. Вместе с этим стоит сказать, что возможности языка Python им не ограничивается. Существует большое количество библиотек, которые позволяют работать с файлами определенных типов, а также допускают более тесное взаимодействие с файловой системой. И в совокупности они предоставляют разработчикам легкий и комфортный способ работы с файлами.

Следите за новыми постами по любимым темам
Подпишитесь на интересующие вас теги, чтобы следить за новыми постами и быть в курсе событий.
Чтение данных из файла и запись в файл
В Python, чтобы создать файл, надо его открыть в режиме записи ( ‘w’ , ‘wb’ ) или дозаписи ( ‘a’ , ‘ab’ ).
f2 = open("text2.txt", 'w')
Функция open() возвращает файловый объект.
Без ‘b’ создается текстовый файл, представляющий собой поток символов. С ‘b’ — файл, содержащий поток байтов.
В Python также существует режим ‘x’ или ‘xb’ . В этом режиме проверяется, есть ли файл. Если файл с определенным именем уже существует, он не будет создан. В режиме ‘w’ файл создается заново, старый при этом теряется.
>>> f1 = open('text1.txt', 'w') >>> f2 = open('text1.txt', 'x') Traceback (most recent call last): File "", line 1, in FileExistsError: [Errno 17] File exists: 'text1.txt' >>> f3 = open('text1.txt', 'w')
Чтение данных из файла
Если в функцию open() не передается второй аргумент, файл расценивается как текстовый и открывается на чтение.
Попытка открыть на чтение несуществующий файл вызывает ошибку.
>>> f = open("text10.txt") Traceback (most recent call last): File "", line 1, in IOError: [Errno 2] No such file or directory: 'text10.txt'
Перехватить возникшее исключение можно с помощью конструкции try-except .
>>> try: . f = open("text10.txt") . except IOError: . print ("No file") . No file
Получить все данные из файла можно с помощью метода read() файлового объекта, предварительно открыв файл на чтение. При этом файловый объект изменяется и получить из него данные еще раз не получится.
>>> f = open("text.txt") >>> f >>> fd = f.read() >>> fd1 = f.read() >>> fd 'Hello\n\tOne\n Two\nThree Four\nШесть!\n' >>> fd1 ''
Если файл был открыт в текстовом режиме, то метод read() возвращает строку. В случае бинарного режима возвращается объект типа bytes .
>>> f = open('text.txt', 'rb') >>> content = f.read() >>> type(content) >>> content b'HelloHello' >>> content[0] 72 >>> chr(content[0]) 'H'
Методу read() может быть передан один аргумент, обозначающий количество символов (если файл был открыт как текстовый) или байт (если файл был открыт как бинарный) для чтения.
>>> f = open("text.txt") >>> fd = f.read(10) >>> fd1 = f.read(5) >>> fd 'Hello\n\tOne' >>> fd1 '\n T'
Метод readline() позволяет получать данные построчно.
>>> f = open("text.txt") >>> f.readline() 'Hello\n' >>> f.readline() '\tOne\n' >>> f.readline() ' Two\n'
Принимает аргумент — число байт или символов.
>>> f.readline(3) 'Thr' >>> f.readline(3) 'ee ' >>> f.readline(3) 'Fou' >>> f.readline(3) 'r\n' >>> f.readline(5) 'Шесть' >>> f.readline(5) '!\n'
Для построчного чтения данных из файла рекомендуется использовать цикл for :
>>> f = open('text.txt') >>> for line in f: . print(line, end='') . Hello! The second line. >>> f.close()
Метод readlines() считывает все строки и помещает их в список.
>>> f = open("text.txt") >>> fd = f.readlines() >>> fd ['Hello\n', '\tOne\n', ' Two\n', 'Three Four\n', 'Шесть!\n']
Может принимать количество символов, но дочитывает строку до конца.
>>> f = open("text.txt") >>> fd = f.readlines(3) >>> fd ['Hello\n'] >>> fd1 = f.readlines(6) >>> fd1 ['\tOne\n', ' Two\n']
Запись данных в файл
Записать данные в файл можно с помощью метода write() , который возвращает число записанных символов или байтов.
>>> ft = open('text1.txt', 'w') >>> fb = open('text2.txt', 'wb') >>> t = 'Привет Мир!' >>> b = b'Hello World!' >>> type(t), type(b) (, ) >>> ft.write(t) 11 >>> fb.write(b) 12 >>> ft.close() >>> fb.close() >>> >>> import os.path >>> os.path.getsize('text1.txt') 20 >>> os.path.getsize('text2.txt') 12 >>> open('text2.txt').read() 'Hello World!'
Если записываемые в текстовый файл данные не являются строкой, то их предварительно надо преобразовать в строку.
>>> a = [1, 2, 3, 4] >>> sa = str(a) >>> sa '[1, 2, 3, 4]' >>> f = open('mylist.txt', 'w') >>> f.write(sa) 12 >>> f.close() >>> >>> with open('mylist.txt') as f: . sa = f.read() . >>> sa '[1, 2, 3, 4]' >>> list(sa) # bad idea ['[', '1', ',', ' ', '2', ',', ' ', '3', ',', ' ', '4', ']'] >>> a = [int(i) for i in sa if i.isdigit()] >>> a [1, 2, 3, 4]
С помощью метода writelines() можно записать в файл итерируемую последовательность.
>>> a = [1,2,3,4,5,6,7,8,9,0] >>> f = open("text2.txt",'w') >>> f.writelines("%s\n" % i for i in a) >>> f.close() >>> open("text2.txt").read() '1\n2\n3\n4\n5\n6\n7\n8\n9\n0\n' >>> print(open("text2.txt").read()) 1 2 3 4 5 6 7 8 9 0
Смена позиции в файле
Метод tell() возвращает текущую позицию в файле. Позицию можно менять с помощью метода seek() .
>>> f = open('text.txt') >>> f.tell() 0 >>> f.readline() 'Hello!\n' >>> f.tell() 7 >>> f.seek(5) 5 >>> f.read(1) '!' >>> f.tell() 6 >>> f.read() '\nThe second line.\n' >>> f.read() '' >>> f.seek(0) 0 >>> f.read() 'Hello!\nThe second line.\n'
В случае бинарных файлов в метод seek() можно передавать второй аргумент, который указывает, с какого места выполняется смещение, указанное в первом аргументе: 0 (по умолчанию) — от начала файла, 1 — с текущей позиции, 2 — с конца.
>>> f = open('text.txt', 'rb') >>> f.read() b'Hello!\nThe second line.\n' >>> f.seek(-6, 2) 18 >>> f.read(4) b'line' >>> f.seek(0) 0 >>> f.read(5) b'Hello' >>> f.seek(2, 1) 7 >>> f.read(3) b'The'
Закрытие файла
В Python следует закрывать файл для высвобождения системных ресурсов. Делается это с помощью метода close() файлового объекта.
С помощью closed (не константа, а так называемый дескриптор, или описатель, данных) проверяют, закрыт файл или нет.
>>> f = open('text.txt') >>> f.closed False >>> f.close() >>> f.closed True
Считается хорошей практикой использовать оператор with при обработке файловых объектов. После того как тело with завершит работу, файл автоматически будет закрыт. При работе with создается так называемый контекстный менеджер, представляющий собой особый объект. Благодаря ему сохраняются и восстанавливаются глобальные состояния, происходит блокировка и разблокировка ресурсов, закрываются открытые файлы и др.
>>> with open('text.txt') as f: . print(f.read()) . HelloHello >>> f.closed True
>>> with open('text.txt') as fr, open('text2.txt', 'w') as fw: . fw.write(fr.read()) . 10 >>> fw.closed True
>>> with ( . open('text.txt') as fr, . open('text2.txt', 'w') as fw, . ): . fw.write(fr.read()) . 10
Двоичные файлы
Пример копирования изображения:
>>> f1 = open('flag.png', 'rb') >>> f2 = open('flag2.png', 'wb') >>> f2.write(f1.read()) 446 >>> f1.close() >>> f2.close()
Модуль struct позволяет преобразовывать данные к бинарному виду и обратно.
>>> f = open('text3.txt', 'wb') >>> f.write('3') Traceback (most recent call last): File "", line 1, in TypeError: 'str' does not support the buffer interface >>> d = struct.pack('>i',3) >>> d b'\x00\x00\x00\x03' >>> f.write(d) 4 >>> f.close() >>> f = open('text3.txt') >>> d = f.read() >>> d '\x00\x00\x00\x03' >>> struct.unpack('>i',d) Traceback (most recent call last): File "", line 1, in TypeError: 'str' does not support the buffer interface >>> f = open('text3.txt', 'rb') >>> d = f.read() >>> d b'\x00\x00\x00\x03' >>> struct.unpack('>i',d) (3,)
Чтение файла построчно в список на Python
В процессе работы с файлами на языке программирования Python часто возникает задача построчного чтения файла и сохранения каждой строки как элемента списка. Допустим, у вас есть текстовый файл, и вы хотите прочитать его содержимое построчно, преобразовав каждую строку в элемент списка.
В Python это можно сделать несколькими способами. Рассмотрим один из самых простых и распространенных.
Использование встроенной функции open()
Первый способ — использовать встроенную функцию open() . В этом случае файл будет открыт в режиме чтения (‘r’) и каждая строка файла будет прочитана и добавлена в список с помощью метода readlines() .
with open('filename.txt', 'r') as file: lines = file.readlines()
В этом примере filename.txt — это имя файла, который вы хотите прочитать. Метод readlines() возвращает список, где каждый элемент списка — это отдельная строка из файла.
Таким образом, после выполнения этого кода, переменная lines будет содержать список строк из файла filename.txt .
Этот метод прост и эффективен, однако стоит учесть, что он считывает весь файл в память сразу. Это может вызвать проблемы при работе с очень большими файлами, которые не умещаются в оперативной памяти компьютера.
Использование генераторов
Если требуется обработать большой файл, который не умещается в память, можно использовать генераторы. В этом случае файл будет считываться построчно, а не полностью, что позволяет значительно снизить потребление памяти.
with open('filename.txt', 'r') as file: lines = [line for line in file]
В этом примере используется генератор списка ( list comprehension ), который построчно читает файл и добавляет каждую строку в список.
Этот способ также прост и эффективен, но в отличие от первого, он позволяет обрабатывать файлы, которые не умещаются в оперативной памяти.
Оба представленных способа позволяют быстро и просто считать содержимое файла в список, выполнив построчное чтение.