Agregar separador de miles en un número

En pitón

 re.sub(r"(?<=.)(?=(?:...)+$)", ",", stroke ) 

Para dividir un número por trillizos, por ejemplo:

 echo 123456789 | python -c 'import sys;import re; print re.sub(r"(?<=.)(?=(?:...)+$)", ",",  sys.stdin.read());'
 123,456,789

¿Cómo hacer lo mismo con bash / awk?

Con sed:

$ echo "123456789" | sed 's/\([[:digit:]]\{3\}\)\([[:digit:]]\{3\}\)\([[:digit:]]\{3\}\)/\1,\2,\3/g'
123,456,789

(¡Tenga en cuenta que esto solo funciona para exactamente 9 dígitos!)

o esto con sed:

$ echo "123456789" | sed ':a;s/\B[0-9]\{3\}\>/,&/;ta'
123,456,789

Con printf:

$ LC_NUMERIC=en_US printf "%'.f\n" 123456789
123,456,789

bash's printfadmite prácticamente todo lo que puede hacer en la printffunción C

type printf           # => printf is a shell builtin
printf "%'d" 123456   # => 123,456

printf de coreutils hará lo mismo

/usr/bin/printf "%'d" 1234567   # => 1,234,567

Puedes usar numfmt:

$ numfmt --grouping 123456789
123,456,789

O:

$ numfmt --g 123456789
123,456,789

Tenga en cuenta que numfmt no es una utilidad POSIX, es parte de los coreutils de GNU.

cat <<'EOF' |
13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096
EOF
perl -wpe '1 while s/(\d+)(\d\d\d)/$1,$2/;'

produce:

13,407,807,929,942,597,099,574,024,998,205,846,127,479,365,820,592,393,377,723,561,443,721,764,030,073,546,976,801,874,298,166,903,427,690,031,858,186,486,050,853,753,882,811,946,569,946,433,649,006,084,096

Esto se logra dividiendo la cadena de dígitos en 2 grupos, el grupo de la derecha con 3 dígitos, el grupo de la izquierda con lo que queda, pero al menos un dígito. Luego, todo se reemplaza por los 2 grupos, separados por una coma. Esto continúa hasta que la sustitución falla. Las opciones "wpe" son para la lista de errores, encierran la declaración dentro de un bucle con una impresión automática y toman el siguiente argumento como el "programa" perl (vea el comando perldoc perlrun para más detalles).

Mis mejores deseos ... salud, drl

Con algunas awkimplementaciones:

echo "123456789" | awk '{ printf("%'"'"'d\n",$1); }'  

123,456,789  

"%'"'"'d\n"es: "%(comilla simple) (comilla doble) (comilla simple) (comilla doble) (comilla simple) d \ n"

Eso usará el separador de miles configurado para su configuración regional (generalmente ,en configuraciones regionales en inglés, espacio en francés, .en español / alemán ...). Lo mismo que devuelto porlocale thousands_sep

Un caso de uso común para mí es modificar la salida de una tubería de comando para que los números decimales se impriman con miles de separadores. En lugar de escribir una función o script, prefiero usar una técnica que pueda personalizar sobre la marcha para cualquier salida de una tubería de Unix.

He encontrado printf(proporcionado por Awk) la forma más flexible y memorable de lograr esto. POSIX especifica el carácter de apóstrofe / comilla simple como un modificador para formatear números decimales y tiene la ventaja de que es compatible con la configuración regional, por lo que no se limita al uso de caracteres de coma.

Al ejecutar comandos Awk desde un shell de Unix, puede haber dificultades para ingresar un carácter de comillas simples dentro de una cadena delimitada por comillas simples (para evitar la expansión del shell de variables posicionales, por ejemplo $1). En este caso, encuentro que la forma más legible y confiable de ingresar el carácter de comillas simples es ingresarlo como una secuencia de escape octal (comenzando por \0).

Ejemplo:

printf "first 1000\nsecond 10000000\n" |
  awk '{printf "%9s: %11\047d\n", $1, $2}'

  first:       1,000
 second:  10,000,000

Salida simulada de una tubería que muestra qué directorios están utilizando la mayor cantidad de espacio en disco:

printf "7654321 /home/export\n110384 /home/incoming\n" |
  awk '{printf "%22s: %9\047d\n", $2, $1}'

  /home/export: 7,654,321
/home/incoming:   110,384

Otras soluciones se enumeran en Cómo escapar de una cita simple dentro de awk .

Nota: como se advirtió en Print a Single Quote , se recomienda evitar el uso de secuencias de escape hexadecimales, ya que no funcionan de manera confiable en diferentes sistemas.

awky bashtener buenas soluciones integradas, basadas en printf, como se describe en las otras respuestas. Pero primero, sed.

Para sed, tenemos que hacerlo "manualmente". La regla general es que si tiene cuatro dígitos consecutivos, seguidos de un no dígito (o final de línea), se debe insertar una coma entre el primer y el segundo dígito.

Por ejemplo,

echo 12345678 | sed -re 's/([0-9])([0-9]{3})($|[^0-9])/\1,\2\3/'

imprimirá

12345,678

Obviamente, debemos seguir repitiendo el proceso para seguir agregando suficientes comas.

sed -re ' :restart ; s/([0-9])([0-9]{3})($|[^0-9])/\1,\2\3/ ; t restart '

En sed, el tcomando especifica una etiqueta a la que se saltará si el último s///comando fue exitoso. Por lo tanto, defino una etiqueta con :restart, para que salte hacia atrás.

Aquí hay una demostración de bash (en ideone ) que funciona con cualquier número de dígitos:

function thousands {
    sed -re ' :restart ; s/([0-9])([0-9]{3})($|[^0-9])/\1,\2\3/ ; t restart '
}                                                 
echo 12 | thousands
echo 1234 | thousands
echo 123456 | thousands
echo 1234567 | thousands
echo 123456789 | thousands
echo 1234567890 | thousands

$ echo 1232323 | awk '{printf(fmt,$1)}' fmt="%'6.3f\n"
12,32,323.000

Si está buscando números GRANDES, no pude hacer que las soluciones anteriores funcionen. Por ejemplo, obtengamos un número realmente grande:

$ echo 2^512 |bc -l|tr -d -c [0-9] 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096

Tenga en cuenta que necesito treliminar el resultado de nueva línea de barra diagonal inversa de bc. Este número es demasiado grande para tratarlo como flotante o número de bit fijo en awk, y ni siquiera quiero construir una expresión regular lo suficientemente grande como para dar cuenta de todos los dígitos en sed. Más bien, puedo revertirlo y poner comas entre grupos de tres dígitos, luego revertirlo:

echo 2^512 |bc -l|tr -d -c [0-9] |rev |sed -e 's/\([0-9][0-9][0-9]\)/\1,/g' |rev 13,407,807,929,942,597,099,574,024,998,205,846,127,479,365,820,592,393,377,723,561,443,721,764,030,073,546,976,801,874,298,166,903,427,690,031,858,186,486,050,853,753,882,811,946,569,946,433,649,006,084,096

a="13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096"

echo "$a" | rev | sed "s#[[:digit:]]\{3\}#&,#g" | rev

13,407,807,929,942,597,099,574,024,998,205,846,127,479,365,820,592,393,377,723,561,443,721,764,030,073,546,976,801,874,298,166,903,427,690,031,858,186,486,050,853,753,882,811,946,569,946,433,649,006,084,096

También quería tener la parte después del separador decimal correctamente separado / espaciado, por lo tanto, escribí este script sed que usa algunas variables de shell para ajustar las preferencias regionales y personales. También tiene en cuenta diferentes convenciones para el número de dígitos agrupados :

#DECIMALSEP='.' # usa                                                                                                               
DECIMALSEP=','  # europe

#THOUSSEP=',' # usa
#THOUSSEP='.' # europe
#THOUSSEP='_' # underscore
#THOUSSEP=' ' # space
THOUSSEP=' '  # thinspace

# group before decimal separator
#GROUPBEFDS=4   # china
GROUPBEFDS=3    # europe and usa

# group after decimal separator
#GROUPAFTDS=5   # used by many publications 
GROUPAFTDS=3


function digitgrouping {
  sed -e '
    s%\([0-9'"$DECIMALSEP"']\+\)'"$THOUSSEP"'%\1__HIDETHOUSSEP__%g
    :restartA ; s%\([0-9]\)\([0-9]\{'"$GROUPBEFDS"'\}\)\(['"$DECIMALSEP$THOUSSEP"']\)%\1'"$THOUSSEP"'\2\3% ; t restartA
    :restartB ; s%\('"$DECIMALSEP"'\([0-9]\{'"$GROUPAFTDS"'\}\'"$THOUSSEP"'\)*\)\([0-9]\{'"$GROUPAFTDS"'\}\)\([0-9]\)%\1\3'"$THOUSSEP"'\4% ; t restartB
    :restartC ; s%\([^'"$DECIMALSEP"'][0-9]\+\)\([0-9]\{'"$GROUPBEFDS"'\}\)\($\|[^0-9]\)%\1'"$THOUSSEP"'\2\3% ; t restartC
    s%__HIDETHOUSSEP__%\'"$THOUSSEP"'%g'
}

Una solución A bash/ awk(según lo solicitado) que funciona independientemente de la longitud del número y se utiliza ,independientemente de la configuración de la thousands_sepconfiguración regional , y dondequiera que estén los números en la entrada y evita agregar el separador de miles después en 1.12345:

echo not number 123456789012345678901234567890 1234.56789 |
  awk '{while (match($0, /(^|[^.0123456789])[0123456789]{4,}/))
        $0 = substr($0, 1, RSTART+RLENGTH-4) "," substr($0, RSTART+RLENGTH-3)
        print}'

Da:

not number 123,456,789,012,345,678,901,234,567,890 1,234.56789

Con awkimplementaciones como mawkesa no son compatibles con los operadores de expresiones regulares de intervalo, cambie la expresión regular a/(^|[^.0123456789])[0123456789][0123456789][0123456789][0123456789]+/