bash - tablas - input html

¿Cómo dividir un archivo de texto grande en archivos más pequeños con igual número de líneas?

Question

Tengo un archivo de texto plano grande (por número de líneas) que me gustaría dividir en archivos más pequeños, también por número de líneas. Entonces, si mi archivo tiene alrededor de 2M líneas, me gustaría dividirlo en 10 archivos que contengan 200k líneas, o 100 archivos que contengan 20k líneas (más un archivo con el resto; no importa si es divisible de manera uniforme).

Podría hacer esto con bastante facilidad en Python, pero me pregunto si hay alguna forma de ninja para hacerlo usando bash y unix utils (en lugar de hacer un bucle manual y contar / crear líneas de partición).

Answer 1

¿Has mirado la orden de división?

$ split --help
Usage: split [OPTION] [INPUT [PREFIX]]
Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default
size is 1000 lines, and default PREFIX is `x''.  With no INPUT, or when INPUT
is -, read standard input.

Mandatory arguments to long options are mandatory for short options too.
  -a, --suffix-length=N   use suffixes of length N (default 2)
  -b, --bytes=SIZE        put SIZE bytes per output file
  -C, --line-bytes=SIZE   put at most SIZE bytes of lines per output file
  -d, --numeric-suffixes  use numeric suffixes instead of alphabetic
  -l, --lines=NUMBER      put NUMBER lines per output file
      --verbose           print a diagnostic to standard error just
                            before each output file is opened
      --help     display this help and exit
      --version  output version information and exit

Podrías hacer algo como esto:

split -l 200000 filename

que creará archivos cada uno con 200000 líneas llamadas xaa xab xac ...

Otra opción, dividida por tamaño del archivo de salida (todavía se divide en saltos de línea):

 split -C 20m --numeric-suffixes input_filename output_prefix

crea archivos como output_prefix01 output_prefix02 output_prefix03 ... cada uno de tamaño máximo de 20 megabytes.

Answer 2

¿Qué tal el comando de split ?

split -l 200000 mybigfile.txt

Answer 3

En caso de que solo quiera dividir por x número de líneas en cada archivo, las respuestas proporcionadas sobre la split están bien. Pero, tengo curiosidad por que nadie haya prestado atención a los requisitos:

• "Sin tener que contarlos" -> usando wc + cut
• "tener el resto en un archivo extra" -> split lo hace por defecto

No puedo hacer eso sin "wc + cut", pero estoy usando eso:

split -l  $(expr `wc $filename | cut -d '' '' -f3` / $chunks) $filename

Esto se puede agregar fácilmente a sus funciones básicas para que solo pueda invocarlo pasando el nombre de archivo y los fragmentos:

 split -l  $(expr `wc $1 | cut -d '' '' -f3` / $2) $1

En caso de que desee solo x trozos sin resto en un archivo adicional, simplemente adapte la fórmula para sumarla (trozos - 1) en cada archivo. Utilizo este enfoque porque generalmente solo quiero x cantidad de archivos en lugar de x líneas por archivo:

split -l  $(expr `wc $1 | cut -d '' '' -f3` / $2 + `expr $2 - 1`) $1

Puedes agregar eso a un script y llamarlo tu "forma ninja", porque si nada satisface tus necesidades, puedes crearlo :-)

Answer 4

HDFS getmerge pequeño archivo y derramado en tamaño de propiedad.

Este método causará salto de línea

split -b 125m compact.file -d -a 3 compact_prefix

Intento obtener y dividir en aproximadamente 128 MB cada archivo.

dividido en 128m, la unidad de tamaño del juez es M o G, por favor haga una prueba antes de usar

begainsize=`hdfs dfs -du -s -h /externaldata/$table_name/$date/ | awk ''{ print $1}'' `
sizeunit=`hdfs dfs -du -s -h /externaldata/$table_name/$date/ | awk ''{ print $2}'' `
if [ $sizeunit = "G" ];then
    res=$(printf "%.f" `echo "scale=5;$begainsize*8 "|bc`)
else
    res=$(printf "%.f" `echo "scale=5;$begainsize/128 "|bc`)  # celling ref http://blog.csdn.net/naiveloafer/article/details/8783518
fi
echo $res
# split into $res files with number suffix.  ref  http://blog.csdn.net/microzone/article/details/52839598
compact_file_name=$compact_file"_"
echo "compact_file_name :"$compact_file_name
split -n l/$res $basedir/$compact_file -d -a 3 $basedir/${compact_file_name}

Answer 5

Sí, hay un comando de split . Se dividirá un archivo por líneas o bytes.

$ split --help
Usage: split [OPTION]... [INPUT [PREFIX]]
Output fixed-size pieces of INPUT to PREFIXaa, PREFIXab, ...; default
size is 1000 lines, and default PREFIX is `x''.  With no INPUT, or when INPUT
is -, read standard input.

Mandatory arguments to long options are mandatory for short options too.
  -a, --suffix-length=N   use suffixes of length N (default 2)
  -b, --bytes=SIZE        put SIZE bytes per output file
  -C, --line-bytes=SIZE   put at most SIZE bytes of lines per output file
  -d, --numeric-suffixes  use numeric suffixes instead of alphabetic
  -l, --lines=NUMBER      put NUMBER lines per output file
      --verbose           print a diagnostic just before each
                            output file is opened
      --help     display this help and exit
      --version  output version information and exit

SIZE may have a multiplier suffix:
b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,
GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.

Answer 6

Utilizar:

sed -n ''1,100p'' filename > output.txt

Aquí, 1 y 100 son los números de línea que capturará en output.txt .

Answer 7

divide el archivo "file.txt" en archivos de 10000 líneas:

split -l 10000 file.txt

Answer 8

también puedes usar awk

awk -vc=1 ''NR%200000==0{++c}{print $0 > c".txt"}'' largefile

Answer 9

usar split

Dividir un archivo en partes de tamaño fijo, crea archivos de salida que contienen secciones consecutivas de INPUT (entrada estándar si no se da ninguna o INPUT es `- '')

Syntax split [options] [INPUT [PREFIX]]

http://ss64.com/bash/split.html

Answer 10

split (de GNU coreutils, desde la versión 8.8 de 2010-12-22 ) incluye el siguiente parámetro:

-n, --number=CHUNKS     generate CHUNKS output files; see explanation below

CHUNKS may be:
  N       split into N files based on size of input
  K/N     output Kth of N to stdout
  l/N     split into N files without splitting lines/records
  l/K/N   output Kth of N to stdout without splitting lines/records
  r/N     like ''l'' but use round robin distribution
  r/K/N   likewise but only output Kth of N to stdout

Por lo tanto, split -n 4 input output. generará cuatro archivos ( output.a{a,b,c,d} ) con la misma cantidad de bytes, pero las líneas se pueden dividir en el medio.

Si queremos conservar líneas completas (es decir, divididas por líneas), esto debería funcionar:

split -n l/4 input output.

Respuesta relacionada: https://.com/a/19031247