Comment supprimer les lignes en double dans un fichier texte?

Un de mes énormes fichiers texte (jusqu’à 2 Gio) contient environ 100 doublons exacts de chaque ligne qu’il contient (inutile dans mon cas, car le fichier est une table de données de type CSV).

Ce dont j'ai besoin, c’est d’éliminer toutes les répétitions (de préférence, mais cela peut être sacrifié pour une amélioration significative des performances) en maintenant l’ordre de séquence original. Dans le résultat, chaque ligne doit être unique. S'il y a 100 lignes égales (généralement, les doublons sont répartis dans le fichier et ne seront pas voisins), il ne restera plus qu'une seule de ces lignes.

J'ai écrit un programme en Scala (considérez-le en Java si vous ne connaissez pas Scala) pour l'implémenter. Mais peut-être existe-t-il des outils natifs C-écrits plus rapides capables de le faire plus rapidement?

MISE À JOUR: la awk '!seen[$0]++' filenamesolution semblait bien fonctionner pour moi tant que les fichiers étaient proches de 2 Gio ou moins, mais maintenant que je vais nettoyer un fichier de 8 Gio, cela ne fonctionne plus. Cela semble prendre une infinité sur un Mac avec 4 Go de RAM et un PC Windows 7 64 bits avec 4 Go de RAM et 6 Go échangés, la mémoire manque. Et je ne suis pas enthousiaste à l'idée d'essayer Linux avec 4 Go de RAM, compte tenu de cette expérience.

Une awksolution vue sur #bash (Freenode):

awk '!seen[$0]++' filename

Il existe une méthode simple (qui n’est pas évidente), qui utilise des utilitaires standard et qui ne nécessite pas une mémoire importante sort, mais qui, dans la plupart des implémentations, offre des optimisations spécifiques pour les fichiers volumineux (un bon algorithme de tri externe). Un avantage de cette méthode est qu’elle ne boucle que sur toutes les lignes des utilitaires spéciaux, jamais des langages interprétés.

<input nl -b a -s : |           # number the lines
sort -t : -k 2 -u |             # sort and uniquify ignoring the line numbers
sort -t : -k 1n |               # sort according to the line numbers
cut -d : -f 2- >output          # remove the line numbers

Si toutes les lignes commencent par un caractère non-blanc, vous pouvez vous passer de certaines des options suivantes:

<input nl | sort -k 2 -u | sort -k 1n | cut -f 2- >output

Pour une grande quantité de duplication, une méthode qui nécessite uniquement de stocker une copie de chaque ligne en mémoire fonctionnera mieux. Avec quelques frais d'interprétation, il y a un script awk très concis pour cela (déjà posté par enzotib ):

<input awk '!seen[$0]++'

De manière moins concise: affichez !seen[$0] {print} {seen[$0] += 1}la ligne courante si elle n’a pas encore été vue, puis incrémentez le seencompteur de cette ligne (les variables non initialisées ou les éléments de tableau ont la valeur numérique 0).

Pour les longues lignes, vous pouvez économiser de la mémoire en ne conservant qu'une somme de contrôle non spoofable (par exemple, un résumé cryptographique) de chaque ligne. Par exemple, avec SHA-1, vous n'avez besoin que de 20 octets plus un temps système constant par ligne. Mais l'informatique digère est plutôt lente; cette méthode ne gagnera que si vous avez un processeur rapide (en particulier avec un accélérateur matériel pour calculer les résumés) et pas beaucoup de mémoire par rapport à la taille du fichier et des lignes suffisamment longues. Aucun utilitaire de base ne vous permet de calculer une somme de contrôle pour chaque ligne; vous devrez supporter les frais d'interprétation de Perl / Python / Ruby /… ou écrire un programme compilé dédié.

<input perl -MDigest::MD5 -ne '$seen{Digest::MD5::md5($_)}++ or print' >output

sort -u big-csv-file.csv > duplicates-removed.csv

Notez que le fichier de sortie sera trié.

En supposant que vous puissiez vous permettre de conserver autant que le fichier dédupliqué en mémoire (si vos données sont effectivement dupliquées par un facteur 100, cela devrait représenter environ 20 Mo + de temps système), vous pouvez le faire très facilement avec Perl.

$ perl -ne 'print unless $dup{$_}++;' input_file > output_file

Cela préserve l'ordre aussi.

Vous pouvez extraire le nombre d'occurrences de chaque ligne du %duphachage si vous le souhaitez, sous forme de bonus gratuit.

Si vous préférez awk, vous devriez le faire aussi (même logique que la version de Perl, même ordre, mêmes données rassemblées dans la dupvariable):

$ awk '{if (++dup[$0] == 1) print $0;}' input_file > output_file

Aucune autre réponse n'ayant fourni de support sur place, en voici une:

gawk -i inplace '!a[$0]++' file

Vous pouvez utiliser uniq http://www.computerhope.com/unix/uuniq.htm

uniq signale ou filtre les lignes répétées d'un fichier.

Python One liners:

python -c "import sys; lines = sys.stdin.readlines(); print ''.join(sorted(set(lines)))" < InputFile

Aucune des réponses ici ne fonctionnant pour moi sur mon Mac, j'ai donc écrit un script python simple qui fonctionne pour moi. J'ignore les espaces de début et de fin et je ne me soucie pas de la consommation de mémoire.

import sys

inputfile = sys.argv[1]
outputfile = sys.argv[2]

with open(inputfile) as f:
    content = f.readlines()

content = [x.strip() for x in content]

my_list = list(set(content))

with open(outputfile, 'w') as output:
    for item in my_list:
        output.write("%s\n" % item)

Enregistrez ce qui précède dans unique.py et exécutez-le comme ceci:

python unique.py inputfile.txt outputfile.txt

Avec bash 4, une solution pure-bash tirant parti des tableaux associatifs peut être utilisée. Voici un exemple

unset llist; declare -A llist;
while read -r line; do
if [[ ${llist[$line]} ]]; then
  continue
else 
  printf '%s\n' "$line"
  llist[$line]="x"
fi
done < file.txt