Jak podzielić duży plik tekstowy na mniejsze pliki o jednakowej liczbie wierszy?

Mam duży (według liczby wierszy) zwykły plik tekstowy, który chciałbym podzielić na mniejsze pliki, również według liczby wierszy. Więc jeśli mój plik ma około 2 mln linii, chciałbym podzielić go na 10 plików zawierających 200 000 linii lub 100 plików zawierających 20 000 linii (plus jeden plik z resztą; bycie równo podzielne nie ma znaczenia).

Mogę to zrobić dość łatwo w Pythonie, ale zastanawiam się, czy istnieje jakiś sposób ninja, aby to zrobić za pomocą narzędzi bash i unix (w przeciwieństwie do ręcznego zapętlania i liczenia / dzielenia linii).

Czy spojrzałeś na polecenie podziału?

$ 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

Możesz zrobić coś takiego:

split -l 200000 filename

który utworzy pliki zawierające 200 000 linii o nazwie xaa xab xac...

Inna opcja, podzielona według rozmiaru pliku wyjściowego (nadal dzieli się przy podziale wierszy):

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

tworzy pliki takie jak output_prefix01 output_prefix02 output_prefix03 ...każdy o maksymalnym rozmiarze 20 megabajtów.

Co powiesz na polecenie split ?

split -l 200000 mybigfile.txt

Tak, jest splitpolecenie. Dzieli plik według linii lub bajtów.

$ 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.

posługiwać się split

Podziel plik na części o stałym rozmiarze, tworzy pliki wyjściowe zawierające kolejne sekcje INPUT (standardowe wejście, jeśli nie podano żadnego lub INPUT to `- ')

Syntax split [options] [INPUT [PREFIX]]

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

Posługiwać się:

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

Tutaj 1 i 100 to numery linii, w których będziesz przechwytywać output.txt.

podziel plik „file.txt” na pliki 10000 linii:

split -l 10000 file.txt

split(z GNU coreutils, od wersji 8.8 z 2010-12-22 ) zawiera następujący parametr:

-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

W ten sposób split -n 4 input output.wygeneruje cztery pliki ( output.a{a,b,c,d}) z taką samą ilością bajtów, ale linie mogą być przerwane w środku.

Jeśli chcemy zachować pełne linie (tj. Dzielić na linie), to powinno działać:

split -n l/4 input output.

Powiązana odpowiedź: https://stackoverflow.com/a/19031247

Jeśli chcesz po prostu podzielić x liczbę wierszy każdego pliku, podane odpowiedzi splitsą w porządku. Ale jestem ciekawy, czy nikt nie zwrócił uwagi na wymagania:

• „bez konieczności ich liczenia” -> za pomocą wc + cut
• „pozostała część w dodatkowym pliku” -> podział domyślnie

Nie mogę tego zrobić bez „wc + cut”, ale używam tego:

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

Można to łatwo dodać do funkcji bashrc, aby można było po prostu wywołać przekazanie nazwy pliku i fragmentów:

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

Jeśli chcesz tylko x fragmentów bez pozostałej części dodatkowego pliku, po prostu dostosuj formułę do sumowania (fragmenty - 1) na każdym pliku. Stosuję to podejście, ponieważ zwykle chcę po prostu x liczby plików zamiast x linii na plik:

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

Możesz dodać to do skryptu i nazwać to „ninja”, ponieważ jeśli nic nie odpowiada twoim potrzebom, możesz go zbudować :-)

możesz także użyć awk

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

HDFS wkleja mały plik i rozlewa do rozmiaru nieruchomości.

Ta metoda spowoduje przerwanie linii

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

Próbuję się zanurzyć i podzielić na około 128 MB na każdy plik.

# split into 128m ,judge sizeunit is M or G ,please test before use.

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}