Как разбить файл на части python

Обновлено: 07.07.2024

Чтобы разделить строку в Python с помощью разделителя, вы можете использовать метод split() класса String для этой строки.

Синтаксис

Синтаксис метода String.split():

str – это строка, которую нужно разделить.
separator – это разделитель, в котором строка разделяется. Если не предусмотрено, то вся строка рассматривается как один фрагмент и возвращается, как элемент в списке.
maxsplit – это максимальное количество разделений, которое можно сделать. Если не предусмотрено, выполняется максимально возможное разбиение.

Пример 1: если есть фрагменты, разделенные запятыми

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

Пример 2: с ограниченным количеством разделений

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

Строка делится на три части и, следовательно, получается 4 части.

Пример 3: без аргументов

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

В этом примере мы разделим строку на произвольное количество пробелов между частями.

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

Как разбить строку на фрагменты определенной длины?

Чтобы разбить строку на фрагменты определенной длины, используйте функцию «Понимание списка» со строкой. Все фрагменты будут возвращены в виде массива.

Мы также можем использовать цикл while, чтобы разделить список на части определенной длины.

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

Образец фрагмента кода

Ниже приведен небольшой фрагмент кода для разделения заданной строки str на фрагменты определенной длины n с использованием понимания списка.

Пример: разделение строки на части

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

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

Пример: по длине

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

Пример: с нулевой длиной блока

В этом примере мы протестируем скрипт с размером 0 и проверим вывод. Функция range() вызывает ошибку ValueError, если ее третий аргумент равен нулю.

Длина блока не должна быть равна нулю, поэтому мы получили ValueError для range().

Пример: с помощью цикла while

В этом примере мы разделим строку на фрагменты с помощью цикла Python While Loop.

Мы узнали, как разделить строку по длине в Python с помощью подробных примеров.

С помощью regex

Вы можете разделить строку в Python с разделителем, определяемым регулярным выражением.

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

Таким образом, разделителем может быть __, _ . _ или . Регулярное выражение для этих разделителей – «[_,] [_,]». [_,] указывает, что символ может соответствовать _ или,.

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

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

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

Мы узнали, как повторно упаковать строку для разделения с помощью регулярных выражений.
Вы можете разделить строку пробелом в качестве разделителя в Python с помощью метода String.split().

В этом руководстве мы узнаем, как разделить строку пробелом в Python с помощью методов String.split() и re.split().

В этом примере мы возьмем строку, содержащую слова, элементы или фрагменты, разделенные пробелом. Затем мы разделим строку по пробелу с помощью метода String.split(), который возвращает список.

Разделение строки на один или несколько смежных пробелов

В этом примере мы возьмем строку с фрагментами, разделенными одним или несколькими одиночными пробелами. Затем мы разделим строку с помощью функции re.split().

Мы будем использовать пакет re в следующей программе. re.split (regular_expression, string) возвращает список фрагментов, отделенных от строки на основе regular_expression.

Регулярное выражение + представляет собой один или несколько немедленно возникающих пробелов. Таким образом, в качестве разделителя рассматривается один или несколько одиночных пробелов.

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

Деление любым символом пробела

В этом примере мы разделим строку на части с любым символом пробела в качестве разделителя.

Ниже приведен список символов пробела из таблицы ASCII.

Шестнадцатеричный код ASCII	Описание
09	Горизонтальная вкладка
0A	Новый перевод строки
0B	Вертикальная табуляция
0D	Возврат каретки или подача формы
20	Пробел

По умолчанию String.split() без переданного аргумента разбивает строку на фрагменты со всеми пробелами в качестве разделителей.

В этом примере мы возьмем строку с элементами или словами, разделенными символом подчеркивания _, разделим строку и сохраним элементы в списке.

Разделение строки одним или несколькими нижними подчеркиваниями

В этом примере мы возьмем строку с элементами или словами, разделенными одним или несколькими символами подчеркивания, разделим строку и сохраним элементы в списке.

Мы будем использовать пакет re в python в следующей программе. re.split (regular_expression, string) возвращает список элементов, отделенных от строки на основе regular expression.

Регулярное выражение _ + представляет одно или несколько подчеркиваний. Таким образом, один или несколько символов подчеркивания считаются разделителями.

Один или несколько смежных подчеркиваний считаются одним разделителем.

Мы узнали, как разделить строку с помощью подчеркивания с помощью методов String.split() и re.split().

Как разделить строку на новую строку?

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

В этом руководстве мы узнаем, как разбить строку на символ новой строки \n в Python, используя методы str.split() и re.split().

Пример: с помощью str.split()

В этом примере мы возьмем многострочную строку string1. Мы вызовем метод split() для этой строки с символом новой строки \n, переданным в качестве аргумента. Команда split() разбивает строку на символ новой строки и возвращает список строк.

Строка также может содержать символы \n в строке, как показано ниже, вместо многострочной строки с тройными кавычками.

Пример: с помощью re.split()

В этом примере мы разделим строку на новую строку, используя метод split() регулярного выражения re package.

Чтобы использовать пакет re, мы должны импортировать его в начале нашей программы.

Пример: деление на одну или несколько новых строк

Синтаксис метода re.split() – re.split (regular expression, string). Функция возвращает список подстрок, отделенных от строки на основе regular expression.

Регулярное выражение \n + представляет одну или несколько смежных новых строк. Таким образом, одна или несколько новых строк считаются разделителем между разделениями.

В этом руководстве мы узнали, как разбить строку на новую строку с помощью методов String.split() и re.split().

Разделение строки запятой

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

В этом руководстве мы узнаем, как разделить строку запятыми с помощью String.split().

Пример 1

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

Пример: одной или несколькими запятыми

Если вы используете String.split() с более чем одной запятой, соседствующей друг с другом, вы получите пустые фрагменты. Пример показан ниже.

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

Регулярное выражение, + представляет одну или несколько запятых. Итак, одна или несколько запятых считаются разделителями.

Одна или несколько смежных запятых считаются одним разделителем.

Разделить строку на список символов

Вы можете разделить строку на список символов в Python разными способами, используя цикл for и класс List.

Пример: с помощью цикла For Loop

В этом примере мы возьмем строку и разделим ее на список символов с помощью цикла for.

Пример: с помощью класса List

В этом примере мы берем строку и передаем ее конструктору List. Строка считается итерируемой и преобразуется в список с каждым символом в строке как элементом списка.

у меня есть некоторые проблемы, пытаясь разделить большие файлы (скажем, около 10ГБ). Основная идея - просто прочитать строки и сгруппировать все, скажем, 40000 строк в один файл. Но есть два способа "чтения" файлов.

1) первый-прочитать весь файл сразу и сделать его в список. Но это потребует загрузки всего файла в память, что болезненно для слишком большого файла. (Думаю, я задавал такие вопросы раньше) В python подходы к чтению всего файла сразу у меня есть попробовал включить:

Ну, тогда я могу просто легко группы 40000 строк в один файл: list[40000,80000] or list[80000,120000] Или преимущество использования списка заключается в том, что мы можем легко указать на определенные строки.

2) Второй способ-читать строку за строкой; обрабатывать строку при ее чтении. Эти строки не будут сохранены в памяти. Примеры включают:

Я уверен, что для gzip.открыть, это f не список, а файловый объект. И, кажется, мы можем только процесс строка за строкой; тогда как я могу выполнить это" сплит " задание? Как я могу указать на определенные строки объекта file?

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

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

. чтобы вы могли написать этот код примерно так:

для файла 10GB второй подход-это явно путь. Вот набросок того, что вам нужно сделать:

открыть входной файл.
откройте первый выходной файл.
читаем одну строку из входного файла и записать его в выходной файл.
поддерживайте подсчет того, сколько строк вы написали в настоящее выходной файл; как только он достигнет 40000, закройте выходной файл и откройте следующий один.
повторите шаги 3-4, пока не достигнут конец входного файла.
закрыть оба файла.

очевидно, что, когда вы делаете работу над файлом, вам нужно будет каким-то образом перебирать содержимое файла-делаете ли вы это вручную или позволяете части API Python делать это за вас (например, метод readlines ()) не важно. В Big O analysis это означает, что вы потратите O(n) Время (n-размер файла).

но чтение файла в память также требует O (n) пространства. Хотя иногда нам нужно прочитать файл 10 gb в память, ваш конкретный проблема не требует этого. Мы можем перебирать объект file напрямую. Конечно, файловый объект требует места, но у нас нет причин держать содержимое файла дважды в двух разных формах.

В прошлой статье я написал о некоторых методах, которые я использую в python для эффективной обработки очень больших наборов данных. Вы можете найти это здесь. Грубо говоря, в нем подробно рассказывается, как можно разбить большой файл на куски, которые затем можно передать на несколько ядер для сокращения времени обработки. Ниже я подробно остановлюсь на этом, сначала создав родительский класс, который превращает данный (большой) файл в порции. Я создаю его таким образом, чтобы дочерние классы можно было легко создавать и адаптировать для конкретных типов файлов, учитывая некоторые примеры. Наконец, я даю некоторые функции обертывания для использования в сочетании с любым из чанков, чтобы чанки могли обрабатываться с использованием нескольких ядер.

Есть один вопрос на который стоит дать ответ, перед тем как вы начнете использовать данный метод повсеместно. Какого размера фалй стоит обрабатывать данным методом? Грубый ответ будет, когда размер данных становится сопоставимым с доступной оперативной памятью. Лучшим ответом будет, когда издержки на чтение каждой отдельной строки (записи) больше, чем операция над этой записью. Вот пример этого случая, хотя это не совсем справедливое сравнение:

Для небольшого 10-мегабайтного файла Fasta мы подсчитываем количество последовательностей, присутствующих в пятой части времени, используя чанки. Я должен быть честным и утверждать, что ускорение в основном связано с отсутствием идентифицирующих символов новой строки в методе чанкинга; но тем не менее, это показывает силу, которую можно иметь, используя куски. Для файла fasta 14 ГБ время для фрагментированных (1 МБ фрагментов) и не фрагментированных методов составляет 55 с и 130 с соответственно.

Возвращаясь на правильный путь, давайте превратим метод chunking в родительский класс, из которого мы можем построить:

Выше мы создаем класс Chunker, у которого есть метод класса chunkify, а также статические методы _EOC, read и parse. Метод chunkify выполняет фактическое разбиение на фрагменты данных файла, возвращая итератор, который выдает кортежи, содержащие начало и размер фрагмента. Это метод класса, так что он может использовать статический метод _EOC (конец фрагмента), чтобы переместить указатель в подходящее место для разделения фрагментов. Для простейшего случая это просто конец / начало новой строки. Методы read и parse считывают данный фрагмент из файла и разбивают его на блоки (отдельные строки в простейшем случае) соответственно. Мы делаем методы non-chunkify статическими, чтобы их можно было вызывать без дополнительных затрат на создание экземпляра класса.

Давайте теперь создадим несколько дочерних элементов этого класса для определенных типов файлов. Во-первых, один из самых известных типов файлов в биоинформатике, FASTA. Ниже приведен фрагмент файла FASTA. Каждая запись имеет строку заголовка, которая начинается с «>», за которым следует уникальный идентификатор последовательности. После строки заголовка следуют одна или несколько строк, задающих последовательность. Последовательности могут представлять собой последовательности белков или нуклеиновых кислот, и они могут содержать пробелы и / или символы выравнивания.

А вот обработка данного файла с применением нашего класса Chunker:

Мы обновляем метод _EOC, чтобы найти, когда одна запись заканчивается, а следующая начинается с определения местоположения «>», после чего мы перематываем указатель дескриптора файла на начало этой строки. Мы также обновляем метод parse, чтобы использовать анализатор fasta из модуля BioPython, что дает объекты SeqRecord для каждой записи в чанке.

В качестве второго более сложного примера приведу пример работы с выводом, полученным с помощью bowtie, выравнивателя коротких операций чтения из данных NGS. Формат состоит из столбцов, разделенных табуляцией, с идентификатором каждого чтения, расположенным в первом столбце. Обратите внимание, что одно чтение может быть выровнено в нескольких местах (до 8 по умолчанию!), Поэтому один и тот же идентификатор появляется в нескольких строках. Небольшой пример раздела результатов приведен ниже.

с соответствующим Chunker, заданным:

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

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

Основная функция должна быть узнаваемой как код из предыдущего поста. Он генерирует пул воркеров, в идеале по одному на каждое ядро, прежде чем использовать данный блок для разделения соответствующего файла на серию фрагментов для обработки. В отличие от предыдущих примеров, мы собираем выходные данные каждой задачи и возвращаем их после завершения обработки. Основная функция действует как оболочка, позволяющая нам определять разные функции обработки и разные чанкеры, как указано переменными worker и chunker соответственно. Мы обернули вызов функции обработки в функцию _workerMP, которая печатает на терминал по мере выполнения задач. Для этого он использует функцию _printMP, так как вам нужно очистить терминал после оператора печати при использовании многоядерной обработки, иначе ничего не появится, пока все задачи не будут выполнены.

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

и используя чанкер FASTA:

И время, которое они занимают, чтобы посчитать последовательности в файле 14GB из ранее:

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

У меня есть большой (по количеству строк) текстовый файл, который я хотел бы разделить на файлы меньшего размера, также по количеству строк. Поэтому, если в моем файле около 2 млн строк, я хотел бы разделить его на 10 файлов, содержащих 200 тыс. строк, или 100 файлов, содержащих 20 тыс. строк (плюс один файл с остатком; равномерность деление не имеет значения).

Для этого можно написать скрипт на PHP или Python, но если вы используете Bash, то вы можете воспользоваться готовой утилитой split, которая умеет разбивать как текстовые, так и бинарные файлы на части указанного размера. Если это текстовый файл, то можно разбить большой файл на файлы равного размера с определённым количеством строк. Эта статья расскажет как пользоваться командой split.

Как разбить текстовый файл на файлы с определённым количеством строк

Чтобы разбить файл по числу строк, выполните команду вида:

Как разбить файлы на тома определённого размера

Если вы хотите разбить файлы по размеру, то используйте опцию -C (файлы будут разбиты по строкам, разрывов строк не будет)

Команда split обычно работает со строками ввода (то есть из текстового файла). Но если мы используем параметр -b, мы заставляем split рассматривать файл как двоичный ввод, а строки игнорируются. Мы можем указать размер файлов, которые мы хотим, вместе с префиксом, который мы хотим для выходных файлов. split также может использовать параметр -d, чтобы дать нам числовую нумерацию (*.01 , *.02 , *.03 и т. д.) для выходных файлов, а не алфавитную, которая применяется по умолчанию (*.aa , *.ab , *.ac, и т.д.). Параметр -a указывает длину суффикса. Команда выглядит так:

где ЧИСЛО — длина расширения (или суффикса), которое мы будем использовать, а РАЗМЕР — это размер результирующих файлов с модификатором единиц (K, M, G и т. д.). К примеру, разделим образ диска на файлы размером 4 ГБ с помощью следующей команды (размер последнего файла будет соответствовать оставшейся части тома, если он не является точно кратным выбранному вами размеру):

Это приведёт к созданию группы файлов (размером 4 ГБ), каждый из которых будет назван префиксом case1.split1, как указано в команде, за которым следует .000, .001, .002 и т. д. Параметр -a с 3 указывает, что мы хотим, чтобы расширение было не менее 3 цифр. Без -a 3 наши файлы будут называться .00 , .01 , .02 и т. д. братите внимание на конечную точку в имени нашего выходного файла. Мы делаем это так, чтобы суффикс добавлялся как расширение файла, а не в конец строки имени.

Как файл разделённый на части собрать в один файл

В приведённой выше команде мы повторно собрали разделённые части в новый файл образа размером 80 ГБ. Исходные разделённые файлы не удаляются.

Читайте также: