Как прочитать массив из файла python
Обновлено: 07.07.2024
В качестве сериализованных структур данных программисты на Python активно используют массивы, списки и словари. Хранение этих структур данных постоянно требует файл или базу данных для работы с ними. Эта статья рассказывает, как печатать список в файл и как считать его обратно в память.
Чтобы записать данные в файл и считать их из файла, язык программирования Python предлагает стандартные методы write() and read() для работы с одиночными строками, а также writelines() и readlines() для работы с множеством строк. Более того, модули pickle и json module предоставляют разумные способы работы с сериализованными наборами данных.
Использование методов read и write
Основные методы отлично работают с символами (строками). Построчное сохранение списка в файл listfile.txt работает следующим образом:
Использование методов writelines и readlines
Как упомянуто в начале этой статьи, Python также содержит два метода writelines() и readlines() , чтобы писать и читать множество строк за один шаг соответственно. Напечатать весь список в файл или на диск поможет следующий код на Python:
Прочитать весь список из файла на диске поможет следующий код на Python:
Открыв файл listfile.txt в строке 5, полностью переделываем список в строке 6. Сначала читаем содержимое файла через readlines() . Затем в цикле for удаляем окончание из каждой строки с помощью метода rstrip() . В конце добавляем строку к списку мест как новый элемент. По сравнению с прошлым листингом код получился более компактным, но его может быть сложнее прочесть начинающим программистам на Python.
Использование модуля pickle
Эти два примера показывают использование строк. Кстати, pickle работает со всеми видами объектов языка Python, такими как строки, числа, определённые в самом коде структуры, а также любые другие встроенные структуры данных Python.
Использование формата JSON
Используемый pickle формат двоичных данных специфичен для Python. Чтобы улучшить взаимодействие между различными программами, JavaScript Object Notation (JSON) предлагает лёгкую в использовании и читаемую для человека схему, и поэтому стал очень популярным.
Следующий пример показывает, как печатать список из элементов различных типов в выходной файл с помощью модуля json. В строке 4 определён основной список. Имея открытым файлом для записи в строке 7, метод dump() хранит основной список в файле, используя JSON.
Читать содержимое выходноо файла обратно в память так же просто, как записывать данные. Соответствующий dump() метод называется load() и работает следующим образом:
Вывод
Методы, показаные выше, разнятся от простой записи/чтенияя данных до сброса/загрузки через двоичные потоки с помощью pickle и JSON. Это значительно упрощает хранение списка и чтение его обратно в память.
Когда я только начинал изучать Python, главным помощником в работе для меня, как наверное и для большинства программистов, был Stack Overflow. Я почерпнул оттуда много полезной информации, в том числе и о работе с файлами. Однако даже такая тривиальная задача, как оказалось, имеет несколько различных решений, отличающихся друг от друга простотой реализации и скоростью работы.
Большинство предложенных методов предполагают чтение файла построчно с дальнейшим разбиением на блоки и их преобразованием из строкового типа в числовой, поскольку Python в отличии от C/C++ работает с файлами как с массивом строк. Выполнить последовательное чтение данных в массив без преобразования типов, как это можно сделать в C/C++, стандартными средствами языка невозможно (насколько мне известно), и это существенно увеличивает время работы программы при обработке больших объемов данных.
Как уже было сказано выше, файлы в Python представляют собой массив строк, поэтому все найденные методы можно символически поделить на два типа в зависимости от используемого подхода:
- построчное считывание с разбиением и преобразованием типов
- использование библиотек, которые средствами других языков (например, C/C++) считывают файл и передают полученные данные интерпретатору Python
Самый популярный и простой вариант. Заключается в построчном чтении с разбиением полученной строки на блоки, которые затем преобразуются к необходимому типу данных (в данном случае float) и добавляются к заранее созданному списку.
Способ аналогичен предыдущему, за исключением того, что преобразованием данных из строкового формата в числовой занимается функция map.
Данный способ можно назвать стрельбой из пушки по воробьям, однако у него все же есть свои плюсы: если данные в файле расположены хаотично и отсутствует постоянная структура, то функции split невозможно задать конкретный разделитель и для решения задачи можно использовать регулярное выражение, которое найдет в строке все числа, несмотря на их расположение и наличие разделителей.
Если данные записаны в виде матрицы с постоянными разделителями, то выполнить их чтение можно при помощи модуля CSV Reader, указав в качестве параметра значение разделителя.
Библиотека Numpy предоставляет широкий набор модулей и функций для обработки числовых данных, в том числе и для чтения массивов из файлов. Одна из реализаций возможна с помощью функции loadtxt, результат работы которой будет записан в numpy.array.
Данный способ не сильно отличается от предыдущего, за исключением того, что genfromtxt предоставляет более широкий набор входных параметров: указание различных типов данных для каждого из столбцов, передача ключей для создания ассоциативного массива и так далее.
Для тестирования скорости чтения числовых данных были сгенерированы 7 тестовых файлов, содержащих 5 столбцов и 10, 100, 1 000, 10 000, 100 000, 1 000 000 и 10 000 000 строк случайных чисел формата float. Размер самого большого файла составил 742 Мб.
Для измерения времени работы программы использовалась функция time. Существует мнение, что измерять с её помощью время работы некорректно. Однако в данном случае меня интересовало работа с большими объемами данных, когда время работы программы составляло несколько десятков секунд. В таком случае отклонение в полсекунды вносило погрешность менее 1%.
Fortran
Несмотря на то, что Fortran считается устаревшим языком, он все еще очень популярен в научном программировании благодаря простоте написания кода, скорости обмена данных и обширном количестве библиотек, созданных за последние полвека.
Например, считать числовую матрицу из файла можно всего за 3 строчки кода при условии корректности входных данных.
Дискуссии о том, что лучше: Fortran или C++ ведутся уже давно, даже среди авторов EasyCoding этот спор возникал несколько раз, поэтому мне было еще интересней протестировать чтение матриц на данном языке.
В ходе эксперимента были протестированы 7 программ на языке Python и по одной на Fortran и C++, код которых представлен выше. Запуск программ осуществлялся на компьютере с Intel Core i5 2.7 GHz и 8 Гб оперативной памяти.
Для запуска программ использовались следующие интерпретаторы и компиляторы:
GNU Fortran (GCC) 6.1.0
Для каждой программы проводилась серия испытаний и измерялось время работы, после чего записывался результат в виде среднего арифметического полученных данных. В таблице ниже жирным в каждой строке выделено наименьшее время работы в зависимости от способа чтения и размера входного файла.
| Число строк | Способ | ||||||||
|---|---|---|---|---|---|---|---|---|---|
| 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 с использованием библиотеки Pandas, который даже обогнал по скорости чтения данных языки C++ и Fortran.
Также из результатов теста можно видеть, что программа на Fortran справилась с чтением данных быстрей аналога на C++, что еще раз доказывает его превосходство над самым популярным языком программирования в мире.
10 комментариев к записи
ошибка в таблице ! 0.044 не меньше чем 0.005 а больше почти в 9 раз!
Нет ошибки. Автор сравнивал скорости Python решений.
С++, который обгонит всё перечисленное:
Причем не особо кошерная реализация. Но соответствует предоставленному коду.
Кошерная реализация это:
Спасибо за приведенное полезное сравнение. Не хватает сравнения скорости записи (в рам для точности)
Необходимо установить соответствующую библиотеку numpy либо из репозиториев, либо посредством pip.
2 способ выдает:
[/, /, /]
при числах в файле:
1 2 3
4 5 6
7 8 9
Что не так?
Проверьте версию интерпретатора Python. В 3.7 работает нормально.
На С++ вы читали потоками, это медленно. Надо было попробовать функциями ввода вывода,fopen, fclose, fread должно быть быстрее. В С++ тоже несколько способов. Могло получиться сопоставимо с лучшим результатом.
Занимаясь научными вычислениями, вы получаете результаты, которые должны быть обязательно сохранены. Самый надежный способ хранения - это загрузка массивов с результатами в файл, так как их легко хранить и передавать. Для данных нужд, NumPy предоставляет очень удобные инструменты, позволяющие производить загрузку и выгрузку массивов в файлы различных форматов, а так же производить их сжатие, необходимое для больших массивов.
6.1. Двоичные файлы NumPy (.npy, .npz)
NumPy имеет два собственных формата файлов .npy - для хранения массивов без сжатия и .npz - для предварительного сжатия массивов. Если массивы, которые необходимо сохранить являются небольшими, то можно воспользоваться функцией numpy.save() . В самом простом случае, данная функция принимает всего два аргумента - имя файла в который будет сохранен массив и имя самого сохраняемого массива. Однако следует помнить, что файл будет сохранен, в той директории в которой происходит выполнение скрипта Python или в указанном месте:
После того как массив сохранен, его можно загрузить из файла с помощью функции numpy.load() , указав в виде строки имя необходимого файла, если он находится в той же директории, что и выполняемый скрипт Python, или путь к нему, если он располагается в другом месте:
Файлы .npy удобны для хранения одного массива, если в одном файле нужно сохранить несколько массивов, то необходимо воспользоваться функцией numpy.savez() , которая сохранит их в несжатом виде в файле NumPy с форматом .npz.
После сохранения массивов в файл .npz они могут быть загружены с помощью, уже знакомой нам, функции numpy.load() . Однако, имена массивов теперь изменились с a , b и c на arr_0 , arr_1 и arr_2 соответственно:
Что бы вместе с массивами сохранялись их оригинальные имена, необходимо в функции numpy.savez() указывать их как ключи словарей Python:
В случае очень больших массивов можно воспользоваться функцией numpy.savez_compressed() .
На самом деле, файлы .npz это просто zip-архив который содержит отдельные файлы .npy для каждого массива.
После того как файл был загружен с помощью функции numpy.savez_compressed() его так же легко загрузить с помощью функции numpy.load() :
6.2. Текстовые файлы (.txt)
Очень часто приходится иметь дело с данными, которые хранятся в обычных текстовых файлах (.txt). Как правило, данные представлены в виде строк, в каждой строке может быть несколько значений, разделенных некоторым символом-разделителем, как правило '' - пробелом, ',' или любым другим символом (или группой символов). Такие файлы, по своей сути, являются текстовыми представлениями таблиц, данные которых необходимо как-то загружать и выгружать.
Для работы с данными в текстовом формате NumPy предоставляет очень гибкие функции, но пока мы ограничимся рассмотрением лишь двух из них numpy.savetxt() и numpy.loadtxt() в самом простом случае их использования.
Если заглянуть в получившийся файл, то мы увидим следующее:
Как видим, одномерный массив записывается в текстовый файл простой последовательностью строк, одно значение - одна строка. Давайте сохраним двумерный массив:
Двумерный массив в получившемся текстовом файле будет выглядеть следующим образом:
Каждой строке в текстовом файле соответствует строка из загруженного массива с разделенными пробелом значениями.
Если попробовать сохранить в текстовый файл трехмерный массив или же массив с большей размерностью, то это приведет к ошибке:
C чем связано такое поведениесказать трудно и можно подумать, что это является большим минусом, однако, напомню, что работа с текстовыми файлами имеет совсем другую основную цель - большие таблицы с данными самого разного типа.
Итак, у нас есть два файла test_1.txt и test_2.txt, теперь загрузим массивы которые в них хранятся с помощью функции numpy.loadtxt() :
Как видим, все довольно просто. Но, мы не рассматривали загрузку данных из реальных таблиц, вид которых может быть очень сложным. Например, у нас есть текстовый файл loadtxt_example.txt со следующими данными:
Функция numpy.loadtxt() позволяет загрузить эти данные в так называемый структурированный массив NumPy:
Обрабатывать отсутствующие значения (строка 8 и 15):
Или выгружать только необходимые столбцы таблицы:
И это только малая часть всех возможностей, которые предоставляет NumPy для работы с данными в текстовом виде. Функция numpy.fromregex() позволяет создавать массивы из текстовых файлов с использованием регулярных выражений, а функция numpy.genfromtxt() имеет более 20 параметров настройки и предоставляет самые гибкие решения создания массивов из текстовых файлов.
6.3. Бинарные файлы
Самым простым и самым быстрым способом сохранения массивов является создание простых двоичных файлов. Однако, при такой форме сохранения теряется информация о порядке байтов данных и точности данных. Чаще всего, этот недостаток, не имеет никакого значения, но ситуации в которых такая потеря может оказаться критичной, все же бывают.
Рассмотрим простой пример:
Как видим, двоичный файл создан не с помощью функции NumPy, а спомощью метода базового класса ndarray объектами которого являются все массивы. Что бы загрузить массив из такого файла необходимо воспользоваться функцией numpy.fromfile() :
Как видим данные полностью и безошибочно загрузились. Тем не менее, будте осторожны, если вы передаете данные в таком виде между машинами с разной архитектурой или другими нюансами, которые связаны с порядком байтов данных и их точностью.
На серьезных олимпиадах, а также во многих других ситуациях вам надо читать данные не с клавиатуры, а из файла, и выводить данные в файл, а не на "экран". В таком случае вы должны знать имена этих файлов; в задачах они, как правило, указаны, на этом сайте имена файлов почти всегда — input.txt для входных данных и output.txt для выходных.
Во многих языках программирования ввод/вывод данных через файлы очень похож на ввод/вывод с клавиатуры — те же команды, только немного другие параметры. В питоне, к сожалению, это не так.
Ввод данных
Самый простой способ ввести данные из файла в питоне — это сразу считать их в массив строк. Это делается так:
Здесь input.txt — файл, откуда надо считать данные, параметр "r" указывает, что вы собираетесь именно читать (read) данные, а не записывать (write, см. ниже). Команда open , как говорят, «открывает файл на чтение», а команда readlines считывает весь файл в массив строк.
Теперь data — это массив строк, каждый элемент которого — это очередная строка из входного файла. Например, если в файле было написано
то data будет содержать массив ["1 2 3\n", "4 5 6\n", "some text\n"] . (Здесь "\n" — это символ перевода строки, он будет на конце каждой строки массива data , кроме, возможно, последней. Если вы считываете числа, то можете о нем не беспокоиться, а если считываете строки и он вам мешает, то, как правило, от него можно избавиться командой a = a.rstrip("\n") , где a — строка, у которого вы хотите его убрать.)
Каждый элемент массива data — это как результат отдельной команды input() , которой вы пользовались для чтения с клавиатуры. Поэтому дальше вы пишете программу так же, как писали и раньше, но вместо каждого очередного обращения к input() вы обращаетесь к очередному элементу массива data . В простых случаях все просто, в более сложных вам надо аккуратно подсчитывать, к какому именно элементу массива вам надо обратиться.
Пример. Пусть во входном файле два числа по одному на строке. Их считываем так (здесь и далее слева — пример чтения с клавиатуры, справа — из файла):
Если же два числа в одной строке:
Более сложный пример: сначала число N , а потом N строк по одному числу в каждой:
Обратите внимание на то, что здесь написано i + 1 — потому что в первой (нулевой) строке было n .
Вывод
Проще всего выводить данные — записав их в одну большую строку и выведя эту строку. Вывод строки в файл делается так:
здесь s — строка, которую нужно вывести. Это должна быть именно строка, а не число и т.д. Используйте функцию str , чтобы превратить что угодно в строку, вручную добавляйте пробелы и переводы строк (перевод строки записывается так: "\n" ).
Пример: пусть надо вывести два числа в одну строку:
open("output.txt", "w").write(str(a) + " " + str(b))
Пусть надо вывести два числа на отдельных строках:
open("output.txt", "w").write(str(a) + "\n" + str(b))
Пусть надо вывести массив чисел по одному числу на строке:
или проще, используя строковую магию:
Имейте в виду, что такой вызов должен быть только один раз. Если вы хотите вызывать функцию write несколько раз, то надо суметь вызвать функцию open только один раз. Рекомендуемый вариант — такой:
Читайте также: