IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Langage Perl Discussion :

[Débutant] Suppression doublon non suivis dans un fichier.


Sujet :

Langage Perl

  1. #1
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Février 2011
    Messages
    5
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations forums :
    Inscription : Février 2011
    Messages : 5
    Points : 1
    Points
    1
    Par défaut [Débutant] Suppression doublon non suivis dans un fichier.
    Je précise que j'ai commencé le perl en début de semaine, et que si il y a des fonctions qui permettent de raccourcir certaines manipulation, je suis preneur... x)
    J'ai un fichier de log de la forme suivant:
    IP - - [DATE:HEURE:MINUTE:SECONDE +GMT] "SITE_WEB HTTP/1.0" 404 6408 "-" "Mozilla/5.0 (compatible; Yahoo! Slurp; http://help.yahoo.com/help/us/ysearch/slurp)"

    Le script doit récupérer les IPs, les dates, heures et minutes de chaque ligne du fichier log.
    J'arrive à récupérer les lignes sans soucis, que j'enregistre dans un tableau tampon.
    Ensuite, sur une période de 10 minutes, je dois supprimer les doublons éventuel du fichier.
    J'ai vu qu'il existait une fonction qui supprimait les doublons lorsqu'ils sont identiques... Mais ce n'est pas exactement ce que je recherche.
    Le soucis de mon script: j'arrive bien à supprimer des doublons mais pas tous.
    Je passe donc d'un log:

    IP_1;23/Jan/2011;06:30
    IP_2;23/Jan/2011;06:30
    IP_3;23/Jan/2011;06:30
    IP_1;23/Jan/2011;06:30
    IP_4;23/Jan/2011;06:30
    IP_1;23/Jan/2011;06:30
    IP_1;23/Jan/2011;06:30
    IP_1;23/Jan/2011;06:30
    IP_2;23/Jan/2011;06:30
    IP_1;23/Jan/2011;06:30

    à

    IP_1;23/Jan/2011;06:30
    IP_2;23/Jan/2011;06:30
    IP_3;23/Jan/2011;06:30
    IP_1;23/Jan/2011;06:30
    IP_4;23/Jan/2011;06:30
    IP_1;23/Jan/2011;06:30
    IP_2;23/Jan/2011;06:30
    IP_1;23/Jan/2011;06:30

    Le code qui analyse les doublons:
    $c --> Variable qui a été initialisé avant pour connaître le nombre de ligne dans 10 minutes.
    $b --> Position actuelle dans le fichier.[
    Avant la boucle le $COMPTEUR vaut 0.




    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    while ($COMPTEUR < $c)
    	{
    		# On obtient la ligne qui va faire les comparaisons.
    		@TAMPON = split (/ /, $TAMPON_2[$b - $c + $COMPTEUR]);
    		# On extrait les informations.
    		$IP_1 = $TAMPON[0]; $DATE_1 = $TAMPON[1]; $HEURE_1 = $TAMPON[2]; $MINUTE_1 = $TAMPON[3];  
    		$INFO = $TAMPON[4];
    		# On initialise le second compteur à la position après le compteur.
    		$COMPTEUR_2 = $COMPTEUR + 1; 
    		if ($INFO == 0)
    		{
    			#print "$INFO $b\n";
    			while ($COMPTEUR_2 < $c)
    			{
    				#print "$COMPTEUR   $COMPTEUR_2\n"; 
    				my $AVANCEE = $b-$c+$COMPTEUR_2;
    				#print "$AVANCEE\n";
    				@TAMPON = split (/ /, $TAMPON_2[$AVANCEE]);
    				$IP_2 = $TAMPON[0]; $DATE_2 = $TAMPON[1]; $HEURE_2 = $TAMPON[2]; $MINUTE_2 = $TAMPON[3];
    				if($IP_1 ne $IP_2)
    				{
    					#Si "$IP_1 = $IP_2  --> Je ne fais rien.\n";
    					$TAMPON_2[$AVANCEE] = "$IP_2 $DATE_2 $HEURE_2 $MINUTE_2 0 0\n";
     
    				}
    				elsif ($IP_1 eq $IP_2)
    				{	
    					$TAMPON_2[$AVANCEE] = "$IP_2 $DATE_2 $HEURE_2 $MINUTE_2 1 1\n";
     
    				}
    				$COMPTEUR_2 ++;
    			}
    			# On modifie la ligne qui a servis à détecter les doublons.
    			$TAMPON_2[$b - $c + $COMPTEUR] = "$IP_1 $DATE_1 $HEURE_1 $MINUTE_1 1 0\n";
    		}
    		# On avance dans le compteur.
    		$COMPTEUR++;
    	}
    Merci d'avance pour votre aide.

  2. #2
    Expert confirmé

    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2009
    Messages
    3 577
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Avril 2009
    Messages : 3 577
    Points : 5 753
    Points
    5 753
    Par défaut
    Pour la suppression des doublons :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    use List::MoreUtils qw(uniq);
     
    @sans_doublon = uniq @doublons;
    Ou à la main :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    my %uniq;
    @sans_doublon = grep !$uniq{$_}++, @doublon;
    Voir aussi : http://perl.developpez.com/sources/?...#ArrayDoublons

  3. #3
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Février 2011
    Messages
    5
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations forums :
    Inscription : Février 2011
    Messages : 5
    Points : 1
    Points
    1
    Par défaut
    Et cela fonctionne même dans mon cas? Les lignes ne sont pas toutes strictement identiques... L'heure, les minutes varient... Seul l'IP peut être identique dans ces intervalles.

  4. #4
    Expert confirmé

    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2009
    Messages
    3 577
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Avril 2009
    Messages : 3 577
    Points : 5 753
    Points
    5 753
    Par défaut
    Dans ce cas, voici une méthode utilisant la transformée schwartzienne :

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    my %uniq;
    @sans_doublon = map { join ";", @$_ } grep { !$uniq{$_->[0]}++ } map { [ split /;/, @doublon ] };
    Bien sur, si tu disposes déjà d'une liste @doublon déjà découpée, tu peux te passer de la dernière étape, voir intégrer le test d'unicité dans ta boucle de traitement principal. Mais pour être plus précis, il faudrait que tu fournisses ton code d'analyse de log.

  5. #5
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Février 2011
    Messages
    5
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations forums :
    Inscription : Février 2011
    Messages : 5
    Points : 1
    Points
    1
    Par défaut
    Pour le moment c'est assez brouillon...
    Le résultat final permet d'avoir un fichier du type numéro-IP;...
    Pour le moment j'utilise un fichier intermédiaire pour comprendre ce qu'il se passe dans mes différentes opérations et de vérifier si ce que je fais est juste... J'ai ajouté des commentaires pour le rendre plus lisible, même si c'est assez "brouillon".
    Je vois comment je pourrais supprimer les doublons mais je dois avouer que je ne sais pas très bien comment faire.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97
    98
    99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117
    118
    119
    120
    121
    122
    123
    124
    125
    126
    127
    128
    129
    130
    131
    132
    133
    134
    #! /usr/bin/perl
     
    # Programme de récupération de donnée dans des fichiers de log afin de retransmettre dans une base SQL
     
    # Utilisation des librairies de programmation
    use warnings;
    use strict;
     
    # Déclaration des variables du programmes.
     
    # Variable "compteur".
    my $i = 0;
    my $b = 0;
    my $c = 0;
    my $d = 0;
    my $COMPTEUR = 0;
    my $COMPTEUR_2 = 0;;
     
    # Variable de vérification.
    my $VERIF = 0;
     
    # Variable "tampon".
    my @TAMPON;
    my @TAMPON_2;
    my @TAMPON_3;
     
    # Variable de "données".
    my $DATE_1;
    my $DATE_2;
    my $DIF_HEURE;
    my $DIF_MINUTE;
    my $FICHIER_ECRITURE = '/home/charles/Programme travail/Analyse_log/resultat.csv';
    my $FICHIER_ECRITURE_2 = '/home/charles/Programme travail/Analyse_log/resultat_2.csv';
    my $HEURE_1;
    my $HEURE_2;
    my @LIGNE_2;
    my $MINUTE_1;
    my $MINUTE_2;
    my $INFO;
    my $IP_1;
    my $IP_2;
    open (FICHIER_1, ">$FICHIER_ECRITURE_2");
    open( FICHIER ,'/home/charles/Programme travail/Analyse_log/test linux/bi21.net_access_log');
     
    # On lit le fichier ligne par ligne et on enregistre dans le tableau LIGNE.
    while(my @LIGNE = <FICHIER>)
    {
    	print "Analyse:";
    	# On analyse le fichier à la recherche des caractères demandés.
    	# Le premier tableau TAMPON sert à recevoir les lignes du fichiers après traitement.
    	# Le second tableau TAMPON_2 sert à fixer le résultat de l'analyse dans une zone qui ne servira qu'à cet effet.
    	while($i != $#LIGNE)
    	{
    		print '.';
    		@TAMPON = split (/ / , $LIGNE[$i]); # On met la ligne dans un tableau en séparant la "phrase" par espace.
    		$TAMPON_2[$i] = "$TAMPON[0] $TAMPON[3]"; # On enregistre toutes les lignes dans un tableau.
    		# Une fois les informations principales récupérées, on prépare la phase deux de l'analyse: on ajoute "0" 			pour signaler que l'on peut
    		# analyser la zone.
    		@TAMPON = split (/:/, $TAMPON_2[$i]);
    		$TAMPON_2[$i] = "$TAMPON[0] $TAMPON[1] $TAMPON[2] 0";
    		$i ++;
    	}
    	# On informe l'utilisateur de la fin de la procédure.
    	print "\nAnalyse du fichier FICHIER terminee.\n";
    }
    # Nous avons finis d'analyser le fichier, on le ferme.
    close(FICHIER);
     
    open  (F2, ">$FICHIER_ECRITURE");
    # Phase de validation de l'opération précédente.
    # Le fichier ne doit contenir que des IPs, des dates, des heures et des minutes épurées.
    while ($d < $#TAMPON_2)
    {
    	@TAMPON = split (/\[/, $TAMPON_2[$d]);
    	$TAMPON_3[0] = "$TAMPON[0] $TAMPON[1]";
    	@TAMPON = split (/ /, $TAMPON_3[0]);
    	$IP_1 = $TAMPON[0]; $DATE_1 = $TAMPON[2]; $HEURE_1 = $TAMPON[3]; $MINUTE_1 = $TAMPON[4];
    	print F2 "$IP_1;$DATE_1;$HEURE_1;$MINUTE_1\n";
    	$d++;
    }
    close(F2);
    # On ferme le fichier en mode écriture.
     
     
     
    # On ré-ouvre le fichier précédemment crée afin de récupérer les informations à modifier.
    # On doit supprimer tous les doublons dans le fichier afin d'avoir un nouveau fichier "pure" pour les requêtes SQL.
    open (FICHIER, "$FICHIER_ECRITURE");
    #On définit le tableau LIGNE comme étant une zone contenant l'ensemble de la nouvelle source.
    @LIGNE_2 = <FICHIER>;
    $i = 0;
    my $a = 0;
    # Tant que l'on a encore des lignes a analyser, on continue l'opération.
    while($i < $#LIGNE_2)
    {
    	# Zone de récupération des informations primaires.
    	@TAMPON = split (/\;/, $LIGNE_2[$i]);
    	$IP_1 = $TAMPON[0]; $DATE_1 = $TAMPON[1]; $HEURE_1 = $TAMPON[2]; $MINUTE_1 = $TAMPON[3];
    	$VERIF = 0;
    	while ($VERIF != 1 && $i < $#LIGNE_2)
    	{
    		# Zone de récupération des informations secondaires.
    		$d++;
    		@TAMPON = split (/\;/, $LIGNE_2[$i]);
    		$IP_2 = $TAMPON[0]; $DATE_2 = $TAMPON[1]; $HEURE_2 = $TAMPON[2]; $MINUTE_2 = $TAMPON[3];
    		# Calcul des différences.	
    		$DIF_MINUTE = $MINUTE_2 - $MINUTE_1;
    		$DIF_HEURE = $HEURE_2 - $HEURE_1;
     
    		# On débute l'analyse des horaires.
    		if ($DATE_1 eq $DATE_2 && $DIF_HEURE == 0 && $DIF_MINUTE > 10)
    		{
    			$VERIF = 1;
    		}
    		elsif ($DATE_1 eq $DATE_2 && $DIF_HEURE ==1 && $DIF_MINUTE > -50)
    		{
    			$VERIF = 1;
    		}
    		elsif ($DATE_1 ne $DATE_2 && $DIF_HEURE == -23 && $DIF_MINUTE > -50)
    		{
    			$VERIF = 1;
    		}
    		else
    		{
    			$i++;
    		}
    		$c++;
    			print FICHIER_1 "$a-$LIGNE_2[$i]";
    	}
    	$a++;
    }
     
    close (FICHIER);
    close (FICHIER_1);

  6. #6
    Expert confirmé

    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Avril 2009
    Messages
    3 577
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 58
    Localisation : France, Bas Rhin (Alsace)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Aéronautique - Marine - Espace - Armement

    Informations forums :
    Inscription : Avril 2009
    Messages : 3 577
    Points : 5 753
    Points
    5 753
    Par défaut
    Ton script est extrêmement compliqué, et utilise des formes syntaxiques pas très adaptées, alors que ta spécification initiale semblait assez simple.
    Pourrais-tu redonner de manière complète le fonctionnement attendu, et un exemple de fichier d'entrée, et de fichier de sortie attendu.

    Dans ton script, les fichiers intermédiaires me semblent inutiles, je ne comprends pas la double boucle de la dernière partie, je n'ai pas saisi si la suppression des IP en doublons devait se faire sur tout le fichier, ou seulement sur des parties (et dans ce cas, délimitées par quoi ?), ...

    Bref, si ton code est opérationnel, tu peux le garder, mais de mon point de vue, il est immaintenable.

  7. #7
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Février 2011
    Messages
    5
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations forums :
    Inscription : Février 2011
    Messages : 5
    Points : 1
    Points
    1
    Par défaut
    Les doubles fichier ne servent effectivement à rien, ils étaient juste là pour vérifier ce qu'il se passait.

    Le problème est le suivant:
    - J'ai un fichier de log, je récupère adresse IP, date, heure, minute.
    - Je dois supprimer les doublons dans des zones de 10 minutes.
    0 -> 10 je supprime les doublons de cette zone.
    10 -> 20 je supprime les doublons de cette zone... etc.

    La première boucle récupère les informations contenu dans le fichier.
    Dans la seconde je récupère les zones de 10 minutes pour les traitées.
    Une fois que j'ai le résultat je suis un peu perdu. ^^"

  8. #8
    Nouveau Candidat au Club
    Profil pro
    Inscrit en
    Février 2011
    Messages
    5
    Détails du profil
    Informations personnelles :
    Âge : 33
    Localisation : France

    Informations forums :
    Inscription : Février 2011
    Messages : 5
    Points : 1
    Points
    1
    Par défaut
    En définitive j'ai trouvé ma solution.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    open (FICHIER_1, "< $FICHIER_ECRITURE_2") or die ("Echec de l'ouverture du fichier.\n");
    my @LIGNE_3 = <FICHIER_1>;
    close (FICHIER_1);
    $c=0;
    while ($c < $#LIGNE_3)
    {
    	print "Avancée: $c sur $#LIGNE_3\n";
    	@TAMPON = split (/\;/, $LIGNE_3[$c]);
    	$IP_1 = "$TAMPON[0]";
    	$c++;
    	if ($IP_1 ne 'NULL')
    	{
    	$d = $c;
    		foreach my $COMPTEUR ($c .. $#LIGNE_3)
    		{
    			$LIGNE_3[$COMPTEUR] = "NULL\n" if ($LIGNE_3[$COMPTEUR] =~ m/$IP_1/);
    			chomp $LIGNE_3[$COMPTEUR];
    		}
    	$c=$d;
    	}
    	else
    	{
    	}
     
    }
    open (FICHIER_3, ">epure.txt") or die ("Echec de l'ouverture du fichier");
    foreach (@LIGNE_3)
    {
    	if ($_ ne 'NULL')
    	{
    	print FICHIER_3 $_. "\n";
    	}
     
    }
    close (FICHIER_3);
    Je n'ai plus que deux autres ajouts à faire et j'aurais terminé. (Ajouter des requêtes SQL + scan de dossier).

Discussions similaires

  1. Réponses: 3
    Dernier message: 26/03/2006, 21h45
  2. [VB6]Suppression d'une ligne dans un fichier
    Par Tyrael62 dans le forum VB 6 et antérieur
    Réponses: 3
    Dernier message: 08/02/2006, 12h20
  3. [VB.NET] [XML] Suppression d'un noeud dans un fichier XML
    Par Hoegaarden dans le forum Windows Forms
    Réponses: 2
    Dernier message: 24/09/2004, 12h24
  4. Réponses: 4
    Dernier message: 02/07/2004, 20h14
  5. Réponses: 14
    Dernier message: 01/12/2003, 18h47

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo