Come visualizzare una linea casuale da un file di testo?

Sto cercando di scrivere uno script di shell. L'idea è quella di selezionare una singola riga a caso dal file di testo e visualizzarla come notifica desktop Ubuntu.

Ma desidero selezionare righe diverse ogni volta che eseguo lo script. C'è qualche soluzione per farlo? Non voglio l'intero script. Solo quella cosa semplice.

È possibile utilizzare l' shufutilità per stampare righe casuali dal file

$ shuf -n 1 filename

-n : numero di righe da stampare

Esempi:

$ shuf -n 1 /etc/passwd

git:x:998:998:git daemon user:/:/bin/bash

$ shuf -n 2 /etc/passwd

avahi:x:84:84:avahi:/:/bin/false
daemon:x:2:2:daemon:/sbin:/bin/false

Puoi anche usare il sortcomando per ottenere una linea casuale dal file.

sort -R filename | head -n1

Solo per divertimento, ecco un soluzione di bash pura che non usa shuf, sort, wc, sed, head, tailo altri strumenti esterni.

L'unico vantaggio rispetto alla shufvariante è che è leggermente più veloce, poiché è puro bash. Sulla mia macchina, per un file di 1000 righe la shufvariante richiede circa 0,1 secondi, mentre il seguente script impiega circa 0,01 secondi;) Quindi, mentre shufè la variante più semplice e più breve, questa è più veloce.

In tutta onestà, continuerei a cercare la shufsoluzione, a meno che l'alta efficienza non sia una preoccupazione importante.

#!/bin/bash

FILE=file.txt

# get line count for $FILE (simulate 'wc -l')
lc=0
while read -r line; do
 ((lc++))
done < $FILE

# get a random number between 1 and $lc
rnd=$RANDOM
let "rnd %= $lc"
((rnd++))

# traverse file and find line number $rnd
i=0
while read -r line; do
 ((i++))
 [ $i -eq $rnd ] && break
done < $FILE

# output random line
printf '%s\n' "$line"

Di 'che hai un file notifications.txt. Dobbiamo contare il numero totale di linee, per determinare l'intervallo del generatore casuale:

$ cat notifications.txt | wc -l

Consente di scrivere nella variabile:

$ LINES=$(cat notifications.txt | wc -l)

Ora per generare il numero da 0a $LINEuseremo la RANDOMvariabile.

$ echo $[ $RANDOM % LINES]

Scriviamolo nella variabile:

$  R_LINE=$(($RANDOM % LINES))

Ora dobbiamo solo stampare questo numero di riga:

$ sed -n "${R_LINE}p" notifications.txt

Informazioni su RANDOM:

   RANDOM Each time this parameter is referenced, a random integer between
          0 and 32767 is generated.  The sequence of random numbers may be
          initialized by assigning a value to RANDOM.  If RANDOM is unset,
          it  loses  its  special  properties,  even if it is subsequently
          reset.

Assicurati che il tuo file contenga meno di 32767 numeri di riga. Vedi questo se hai bisogno di un generatore casuale più grande che funzioni immediatamente.

Esempio:

$ od -A n -t d -N 3 /dev/urandom | tr -d ' '

Ecco uno script Python che seleziona una linea casuale da file di input o stdin:

#!/usr/bin/env python
"""Usage: select-random [<file>]..."""
import random

def select_random(iterable, default=None, random=random):
    """Select a random element from iterable.

    Return default if iterable is empty.
    If iterable is a sequence then random.choice() is used for efficiency instead.
    If iterable is an iterator; it is exhausted.
    O(n)-time, O(1)-space algorithm.
    """
    try:
        return random.choice(iterable) # O(1) time and space
    except IndexError: # empty sequence
        return default
    except TypeError: # not a sequence
        return select_random_it(iter(iterable), default, random.randrange)

def select_random_it(iterator, default=None, randrange=random.randrange):
    """Return a random element from iterator.

    Return default if iterator is empty.
    iterator is exhausted.
    O(n)-time, O(1)-space algorithm.
    """
    # from /programming//a/1456750/4279
    # select 1st item with probability 100% (if input is one item, return it)
    # select 2nd item with probability 50% (or 50% the selection stays the 1st)
    # select 3rd item with probability 33.(3)%
    # select nth item with probability 1/n
    selection = default
    for i, item in enumerate(iterator, start=1):
        if randrange(i) == 0: # random [0..i)
            selection = item
    return selection

if __name__ == "__main__":
    import fileinput
    import sys

    random_line = select_random_it(fileinput.input(), '\n')
    sys.stdout.write(random_line)
    if not random_line.endswith('\n'):
        sys.stdout.write('\n') # always append newline at the end

L'algoritmo è O (n) -time, O (1) -space. Funziona con file di dimensioni superiori a 32767 linee. Non carica i file di input in memoria. Legge ogni riga di input esattamente una volta, ovvero è possibile reindirizzare arbitrariamente contenuto di grandi dimensioni (ma finito). Ecco una spiegazione dell'algoritmo .

Sono impressionato dal lavoro svolto da Malte Skoruppa e altri, ma ecco un modo "semplice bash" molto più semplice per farlo:

IFS=$'\012'
# set field separator to newline only
lines=( $(<test5) )
# slurp entire file into an array
numlines=${#lines[@]}
# count the array elements
num=$(( $RANDOM$RANDOM$RANDOM % numlines ))
# get a (more-or-less) random number within the correct range
line=${lines[$num]}
# select the element corresponding to the random number
echo $line
# display it

Come alcuni hanno notato, $ RANDOM non è casuale. Tuttavia, il limite della dimensione del file di 32767 righe viene superato mettendo insieme $ RANDOM secondo necessità.