Mantenga solo las líneas que contienen el número exacto de delimitadores

Tengo un gran archivo csv con 10 campos separados por comas. Desafortunadamente, algunas líneas están mal formadas y no contienen exactamente 10 comas (lo que causa algunos problemas cuando quiero leer el archivo en R). ¿Cómo puedo filtrar solo las líneas que contienen exactamente 10 comas?

Otro POSIX:

awk -F , 'NF == 11' <file

Si la línea tiene 10 comas, habrá 11 campos en esta línea. Así que simplemente hacemos awkuso ,como delimitador de campo. Si el número de campos es 11, la condición NF == 11es verdadera, awkluego realiza la acción predeterminada print $0.

Usando egrep(o grep -Een POSIX):

egrep "^([^,]*,){10}[^,]*$" file.csv

Esto filtra cualquier cosa que no contenga 10 comas: coincide con líneas completas ( ^al principio y $al final), que contiene exactamente diez repeticiones ( {10}) de la secuencia "cualquier número de caracteres excepto ',', seguido de un solo ','" ( ([^,]*,)), seguido de nuevo por cualquier número de caracteres excepto ',' ( [^,]*).

También puede usar el -xparámetro para soltar los anclajes:

grep -xE "([^,]*,){10}[^,]*" file.csv

Esto es menos eficiente que cuonglm 's awksolución sin embargo; este último es típicamente seis veces más rápido en mi sistema para líneas con alrededor de 10 comas. Las líneas más largas causarán grandes ralentizaciones.

El grepcódigo más simple que funcionará:

grep -xE '([^,]*,){10}[^,]*'

Explicación:

-xasegura que el patrón debe coincidir con la línea completa , en lugar de solo una parte de ella. Esto es importante para que no coincidan las líneas con más de 10 comas.

-E significa "expresión regular extendida", lo que hace que se reduzca la barra invertida en su expresión regular.

Los paréntesis se usan para agrupar, y {10}luego significa que debe haber exactamente diez coincidencias en una fila del patrón dentro de las paréntesis.

[^,]es una clase de caracteres; por ejemplo, [c-f]coincidiría con cualquier carácter único que sea a c, a d, an eo an f, y [^A-Z]coincidiría con cualquier carácter único que NO sea una letra mayúscula. Por lo tanto, [^,]coincide con cualquier carácter, excepto una coma.

El *después de que los medios de clase de caracteres "cero o más de estos."

Entonces, la parte regex ([^,]*,)significa "Cualquier carácter excepto una coma cualquier número de veces (incluyendo cero veces), seguido de una coma" y {10}especifica 10 de estos. Luego, [^,]*para que coincida con el resto de los caracteres que no son comas al final de la línea.

sed -ne's/,//11;t' -e's/,/&/10p' <in >out

Eso primero ramifica cualquier línea con 11 o más comas, y luego imprime lo que queda solo aquellas que coinciden con 10 comas.

Aparentemente respondí esto antes ... Aquí hay un plagio de mí de una pregunta que busca exactamente 4 ocurrencias de algún patrón:

Puede orientar [num]la aparición de un patrón con un s///comando de sustitución de sed simplemente agregando [num]el comando. Cuando testá buscando una sustitución exitosa y no especifica una :etiqueta de destino , el test se ramifica fuera del guión. Esto significa que todo lo que tiene que hacer es probar s///5o más comas, luego imprimir lo que queda.

O, al menos, que maneja las líneas que exceden su máximo de 4. Aparentemente, también tiene un requisito mínimo. Afortunadamente, eso es igual de simple:

sed -ne 's|,||5;t' -e 's||,|4p'

... solo reemplace la cuarta aparición de ,en una línea consigo mismo y agregue psu s///pista a las banderas de sustitución. Debido a que las líneas que coinciden ,5 o más veces ya se han eliminado, las líneas que contienen 4 ,coincidencias contienen solo 4.

Lanzando algo corto python:

#!/usr/bin/env python2
with open('file.csv') as f:
    print '\n'.join(line for line in f if line.count(',') == 10)

Esto leerá cada línea y verificará si el número de comas en la línea es igual a 10 line.count(',') == 10, si es así, imprima la línea.

Y aquí hay una manera de Perl:

perl -F, -ane 'print if $#F==10'

Las -ncausas perlpara leer su archivo de entrada línea por línea y ejecutar el script dado por -een cada línea. Se -aactiva la división automática: cada línea de entrada se dividirá en el valor dado por -F(aquí, una coma) y se guardará como la matriz @F.

El $#F(o, más generalmente $#array), es el índice más alto de la matriz @F. Como las matrices comienzan en 0, una línea con 11 campos tendrá un @Fde 10. El script, por lo tanto, imprime la línea si tiene exactamente 11 campos.

Si los campos pueden contener comas o líneas nuevas, su código debe comprender csv. Ejemplo (con tres columnas):

$ cat filter.csv
a,b,c
d,"e,f",g
1,2,3,4
one,two,"three
...continued"

$ cat filter.csv | python3 -c 'import sys, csv
> csv.writer(sys.stdout).writerows(
> row for row in csv.reader(sys.stdin) if len(row) == 3)
> '
a,b,c
d,"e,f",g
one,two,"three
...continued"

Supongo que la mayoría de las soluciones hasta ahora descartarían la segunda y cuarta fila.