Como posso embaralhar as linhas de um arquivo de texto na linha de comando do Unix ou em um shell script?

Quero embaralhar as linhas de um arquivo de texto aleatoriamente e criar um novo arquivo. O arquivo pode ter vários milhares de linhas.

Como posso fazer isso com cat, awk, cut, etc?

Você pode usar shuf. Em alguns sistemas, pelo menos (não parece estar no POSIX).

Como jleedev apontou: sort -Rtambém pode ser uma opção. Em alguns sistemas, pelo menos; bem, você entendeu. Foi apontado que sort -R, na verdade, não se embaralha, mas ordena os itens de acordo com seu valor de hash.

^{[Nota do editor: sort -R quase embaralha, exceto que linhas duplicadas / teclas de classificação sempre terminam próximas uma da outra . Em outras palavras: somente com linhas / teclas de entrada exclusivas, é uma verdadeira reprodução aleatória. Embora seja verdade que a ordem de saída é determinada por valores de hash , a aleatoriedade vem da escolha de uma função de hash aleatória - consulte o manual .]}

O one-liner do Perl seria uma versão simples da solução da Maxim

perl -MList::Util=shuffle -e 'print shuffle(<STDIN>);' < myfile

Esta resposta complementa as muitas ótimas respostas existentes das seguintes maneiras:

• As respostas existentes são empacotadas em funções de shell flexíveis :

  • As funções recebem não apenas stdinentrada, mas também argumentos de nome de arquivo
  • As funções tomam medidas extras para lidar SIGPIPEda maneira usual (terminação silenciosa com código de saída 141), em vez de quebrar ruidosamente. Isso é importante ao canalizar a saída da função para um tubo que é fechado mais cedo, como ao canalizar head.

• Uma comparação de desempenho é feita.

• Função compatível com POSIX com base em awk, sortecut adaptada da própria resposta do OP :

shuf() { awk 'BEGIN {srand(); OFMT="%.17f"} {print rand(), $0}' "$@" |
               sort -k1,1n | cut -d ' ' -f2-; }

• Função baseada em Perl - adaptada da resposta de Moonyoung Kang :

shuf() { perl -MList::Util=shuffle -e 'print shuffle(<>);' "$@"; }

• Função baseada em Python , adaptada da resposta do scai :

shuf() { python -c '
import sys, random, fileinput; from signal import signal, SIGPIPE, SIG_DFL;    
signal(SIGPIPE, SIG_DFL); lines=[line for line in fileinput.input()];   
random.shuffle(lines); sys.stdout.write("".join(lines))
' "$@"; }

^{Consulte a seção inferior para uma versão do Windows desta função.}

• Função baseada em Ruby , adaptada da resposta de hoffmanc :

shuf() { ruby -e 'Signal.trap("SIGPIPE", "SYSTEM_DEFAULT");
                     puts ARGF.readlines.shuffle' "$@"; }

Comparação de desempenho:

Nota: Esses números foram obtidos em um iMac de final de 2012 com Intel Core i5 de 3,2 GHz e um Fusion Drive, executando o OSX 10.10.3. Embora os tempos variem com o SO usado, as especificações da máquina, a awkimplementação usada (por exemplo, a awkversão BSD usada no OSX é geralmente mais lenta que o GNU awke especialmente mawk), isso deve fornecer uma sensação geral de desempenho relativo .

Arquivo de entrada é um arquivo de 1 milhão de linhas produzido com seq -f 'line %.0f' 1000000.
Os horários são listados em ordem crescente (mais rápido primeiro):

• shuf
  • 0.090s
• Ruby 2.0.0
  • 0.289s
• Perl 5.18.2
  • 0.589s
• Pitão
  • 1.342scom Python 2.7.6; 2.407s(!) com Python 3.4.2
• awk+ sort+cut
  • 3.003scom BSD awk; 2.388scom GNU awk(4.1.1); 1.811scom mawk(1.3.4);

Para uma comparação mais detalhada, as soluções não empacotadas como funções acima:

• sort -R (não é uma verdadeira reprodução aleatória se houver linhas de entrada duplicadas)
  • 10.661s - alocar mais memória não parece fazer diferença
• Scala
  • 24.229s
• bash loops + sort
  • 32.593s

Conclusões :

• Use shuf, se puder - é o mais rápido de longe.
• Ruby faz bem, seguido por Perl .
• O Python é visivelmente mais lento que o Ruby e Perl e, comparando as versões do Python, o 2.7.6 é um pouco mais rápido que o 3.4.1
• Use o combo + awk+ compatível com POSIX como último recursosortcut ; qual awkimplementação você usa é importante ( mawké mais rápida que o GNU awk, BSDawk é mais lento).
• Fique longe de sort -R, bashloops, e Scala.

Versões do Windows da solução Python (o código Python é idêntico, exceto pelas variações nas citações e pela remoção das instruções relacionadas ao sinal, que não são suportadas no Windows):

• Para o PowerShell (no Windows PowerShell, você precisará ajustar $OutputEncodingse desejar enviar caracteres não ASCII por meio do pipeline):

# Call as `shuf someFile.txt` or `Get-Content someFile.txt | shuf`
function shuf {
  $Input | python -c @'
import sys, random, fileinput;
lines=[line for line in fileinput.input()];
random.shuffle(lines); sys.stdout.write(''.join(lines))
'@ $args  
}

Observe que o PowerShell pode embaralhar nativamente por meio de seu Get-Randomcmdlet (embora o desempenho possa ser um problema); por exemplo:
Get-Content someFile.txt | Get-Random -Count ([int]::MaxValue)

• Para cmd.exe(um arquivo em lotes):

Salve no arquivo shuf.cmd, por exemplo:

@echo off
python -c "import sys, random, fileinput; lines=[line for line in fileinput.input()]; random.shuffle(lines); sys.stdout.write(''.join(lines))" %*

Eu uso um pequeno script perl, que eu chamo de "unsort":

#!/usr/bin/perl
use List::Util 'shuffle';
@list = <STDIN>;
print shuffle(@list);

Eu também tenho uma versão delimitada por NULL, chamada "unsort0" ... útil para usar com o find -print0 e assim por diante.

PS: Votado como 'shuf' também, eu não fazia ideia de que existia no coreutils hoje em dia ... o acima pode ainda ser útil se o seu sistema não tiver 'shuf'.

Aqui está uma primeira tentativa que é fácil no codificador, mas difícil na CPU, que acrescenta um número aleatório a cada linha, classifica-os e retira o número aleatório de cada linha. Com efeito, as linhas são classificadas aleatoriamente:

cat myfile | awk 'BEGIN{srand();}{print rand()"\t"$0}' | sort -k1 -n | cut -f2- > myfile.shuffled

aqui está um script awk

awk 'BEGIN{srand() }
{ lines[++d]=$0 }
END{
    while (1){
    if (e==d) {break}
        RANDOM = int(1 + rand() * d)
        if ( RANDOM in lines  ){
            print lines[RANDOM]
            delete lines[RANDOM]
            ++e
        }
    }
}' file

resultado

$ cat file
1
2
3
4
5
6
7
8
9
10

$ ./shell.sh
7
5
10
9
6
8
2
1
3
4

Um one-liner para python:

python -c "import random, sys; lines = open(sys.argv[1]).readlines(); random.shuffle(lines); print ''.join(lines)," myFile

E para imprimir apenas uma única linha aleatória:

python -c "import random, sys; print random.choice(open(sys.argv[1]).readlines())," myFile

Mas veja este post para as desvantagens do python random.shuffle(). Não funcionará bem com muitos elementos (mais de 2080).

Função simples baseada em awk fará o trabalho:

shuffle() { 
    awk 'BEGIN{srand();} {printf "%06d %s\n", rand()*1000000, $0;}' | sort -n | cut -c8-
}

uso:

any_command | shuffle

Isso deve funcionar em quase qualquer UNIX. Testado em Linux, Solaris e HP-UX.

Atualizar:

Observe que zeros à esquerda ( %06d) e rand()multiplicação fazem com que funcione corretamente também em sistemas onde sortnão entende números. Ele pode ser classificado por ordem lexicográfica (também conhecida como comparação normal de cadeias).

Ruby FTW:

ls | ruby -e 'puts STDIN.readlines.shuffle'

Um liner para Python com base na resposta do scai , mas a) pega stdin, b) torna o resultado repetível com a semente, c) escolhe apenas 200 de todas as linhas.

$ cat file | python -c "import random, sys; 
  random.seed(100); print ''.join(random.sample(sys.stdin.readlines(), 200))," \
  > 200lines.txt

Uma maneira simples e intuitiva seria usar shuf .

Exemplo:

Assuma words.txtcomo:

the
an
linux
ubuntu
life
good
breeze

Para embaralhar as linhas, faça:

$ shuf words.txt

o que jogaria as linhas embaralhadas para a saída padrão ; Então, você deve canalizá- lo para um arquivo de saída como:

$ shuf words.txt > shuffled_words.txt

Uma dessas execuções aleatórias poderia render:

breeze
the
linux
an
ubuntu
good
life

Temos um pacote para fazer o mesmo trabalho:

sudo apt-get install randomize-lines

Exemplo:

Crie uma lista ordenada de números e salve-a em 1000.txt:

seq 1000 > 1000.txt

para embaralhar, basta usar

rl 1000.txt

Este é um script python que salvei como rand.py na minha pasta pessoal:

#!/bin/python

import sys
import random

if __name__ == '__main__':
  with open(sys.argv[1], 'r') as f:
    flist = f.readlines()
    random.shuffle(flist)

    for line in flist:
      print line.strip()

No Mac OSX sort -Re shufnão estão disponíveis, você pode usar o alias em seu bash_profile como:

alias shuf='python rand.py'

Se, como eu, você veio aqui para procurar uma alternativa shufpara o macOS, use randomize-lines.

Instale o randomize-linespacote (homebrew), que possui um rlcomando com funcionalidade semelhante a shuf.

brew install randomize-lines

Usage: rl [OPTION]... [FILE]...
Randomize the lines of a file (or stdin).

  -c, --count=N  select N lines from the file
  -r, --reselect lines may be selected multiple times
  -o, --output=FILE
                 send output to file
  -d, --delimiter=DELIM
                 specify line delimiter (one character)
  -0, --null     set line delimiter to null character
                 (useful with find -print0)
  -n, --line-number
                 print line number with output lines
  -q, --quiet, --silent
                 do not output any errors or warnings
  -h, --help     display this help and exit
  -V, --version  output version information and exit

Se você tem o Scala instalado, aqui está uma lista para embaralhar a entrada:

ls -1 | scala -e 'for (l <- util.Random.shuffle(io.Source.stdin.getLines.toList)) println(l)'

Esta função bash tem a dependência mínima (somente classificação e bash):

shuf() {
while read -r x;do
    echo $RANDOM$'\x1f'$x
done | sort |
while IFS=$'\x1f' read -r x y;do
    echo $y
done
}

No Windows, você pode tentar este arquivo em lotes para ajudá-lo a embaralhar seus dados.txt. O uso do código em lotes é

C:\> type list.txt | shuffle.bat > maclist_temp.txt

Após emitir este comando, o maclist_temp.txt conterá uma lista aleatória de linhas.

Espero que isto ajude.

Ainda não mencionado:

1. O unsortutil. Sintaxe (um pouco orientada para a lista de reprodução):

   unsort [-hvrpncmMsz0l] [--help] [--version] [--random] [--heuristic]
          [--identity] [--filenames[=profile]] [--separator sep] [--concatenate] 
          [--merge] [--merge-random] [--seed integer] [--zero-terminated] [--null] 
          [--linefeed] [file ...]

2. msort pode embaralhar por linha, mas geralmente é um exagero:

   seq 10 | msort -jq -b -l -n 1 -c r

Outra awkvariante:

#!/usr/bin/awk -f
# usage:
# awk -f randomize_lines.awk lines.txt
# usage after "chmod +x randomize_lines.awk":
# randomize_lines.awk lines.txt

BEGIN {
  FS = "\n";
  srand();
}

{
  lines[ rand()] = $0;
}

END {
  for( k in lines ){
    print lines[k];
  }
}