Sélectionner des lignes aléatoires dans un fichier

Question

Dans un script de Bash, je veux extraire N lignes aléatoires du fichier d'entrée et les sortir dans un autre fichier.

Comment cela peut-il être fait ?

Answer 1

Utilice shuf avec le -n comme indiqué ci-dessous, pour obtenir N des lignes aléatoires :

shuf -n N input > output

Answer 2

Trier le fichier au hasard et choisir le premier 100 lignes :

lines=100
input_file=/usr/share/dict/words

# This is the basic selection method
<$input_file sort -R | head -n $lines

# If the file has duplicates that must never cause duplicate results
<$input_file sort | uniq        | sort -R | head -n $lines

# If the file has blank lines that must be filtered, use sed
<$input_file sed $'/^[ \t]*$/d' | sort -R | head -n $lines

Bien sûr. <$input_file peut être remplacé par n'importe quelle entrée standard canalisée. Cette ( sort -R y $'...\t...' pour obtenir sed pour faire correspondre les caractères de tabulation) fonctionne avec GNU/Linux et BSD/macOS.

Answer 3

D'après un commentaire sur la réponse à la question sur le brassage, il a brassé 78 000 000 000 de lignes en moins d'une minute.

Défi accepté...

EDIT : J'ai battu mon propre record

powershuf l'a fait en 0.047 secondes

$ time ./powershuf.py -n 10 --file lines_78000000000.txt > /dev/null 
./powershuf.py -n 10 --file lines_78000000000.txt > /dev/null  0.02s user 0.01s system 80% cpu 0.047 total

La raison pour laquelle c'est si rapide, c'est que je ne lis pas tout le fichier et je me contente de déplacer le pointeur de fichier 10 fois et d'imprimer la ligne qui suit le pointeur.

Repo Gitlab

Vieille tentative

J'avais d'abord besoin d'un fichier de 78.000.000.000 lignes :

seq 1 78 | xargs -n 1 -P 16 -I% seq 1 1000 | xargs -n 1 -P 16 -I% echo "" > lines_78000.txt
seq 1 1000 | xargs -n 1 -P 16 -I% cat lines_78000.txt > lines_78000000.txt
seq 1 1000 | xargs -n 1 -P 16 -I% cat lines_78000000.txt > lines_78000000000.txt

Cela me donne un fichier avec 78 milliards d'euros nouvelles lignes ;-)

Maintenant pour la partie "shuf" :

$ time shuf -n 10 lines_78000000000.txt

shuf -n 10 lines_78000000000.txt  2171.20s user 22.17s system 99% cpu 36:35.80 total

Le goulot d'étranglement était le CPU et le fait de ne pas utiliser de threads multiples, il a bloqué un cœur à 100%, les 15 autres n'ont pas été utilisés.

Python est ce que j'utilise régulièrement, c'est donc ce que je vais utiliser pour accélérer le processus :

#!/bin/python3
import random
f = open("lines_78000000000.txt", "rt")
count = 0
while 1:
  buffer = f.read(65536)
  if not buffer: break
  count += buffer.count('\n')

for i in range(10):
  f.readline(random.randint(1, count))

Ça m'a pris un peu moins d'une minute :

$ time ./shuf.py         

./shuf.py  42.57s user 16.19s system 98% cpu 59.752 total

Je l'ai fait sur un Lenovo X1 extreme 2nd gen avec le i9 et Samsung NVMe qui me donne beaucoup de vitesse de lecture et d'écriture.

Je sais que ça peut aller plus vite mais je laisse un peu de place pour que d'autres puissent essayer.

Compteur de lignes source : Luther Blissett

Answer 4

Mon option préférée est très rapide, j'ai échantillonné un fichier de données délimité par des tabulations avec 13 colonnes, 23.1M lignes, 2.0GB non compressé.

# randomly sample select 5% of lines in file
# including header row, exclude blank lines, new seed

time \
awk 'BEGIN  {srand()} 
     !/^$/  { if (rand() <= .05 || FNR==1) print > "data-sample.txt"}' data.txt

# awk  tsv004  3.76s user 1.46s system 91% cpu 5.716 total

Answer 5

seq 1 100 | python3 -c 'print(__import__("random").choice(__import__("sys").stdin.readlines()))'