Besoin d'aide pour trier des lignes dans un fichier

Oups désolé, je croyais avoir vu ton post dans le forum GNU/Linux, d'où ma réponse avec "awk" ;-\

Merci beaucoup !

Pas de soucis, j'avais pas pensé qu'on pouvais le faire en bash, mais ca à l'air un peu plus simple et surtout ça marche, j'ai réussi à obtenir mon fichier, en modifiant un peu ta commande:
$ awk '/^KI/ && / Y / { print $0}' sortie_signalP>sortie.txt

Sur mon fichier à traiter les nom de protéines commençaient par KI au lieu de IPI et j'ai un peu galéré pour reussir à trouver comment imprimer dans un fichier plutôt que dans la console mais j'ai bien obtenu ce que je voulais !

Par contre je n'ai pas bien compris ce que représentait $0 après le print ?

Bonne journée

Jo

Par contre je n'ai pas bien compris ce que représentait $0 après le print ?

$0 représente la ligne en cours, mais c'est facultatif, un print tout court aura le même effet.

salut zipe

ah ? et alors à quoi sert de mettre ces caractères non indispensables?

soit dit en passant, tu connais bien Perl ? quel(s) langage(s) utilises-tu ?

ah ? et alors à quoi sert de mettre ces caractères non indispensables?
A faire joli ;-))
Non, en fait je ne connais que très sommairement awk et ne maîtrise pas toutes ses subtilités. Peut être aussi que sur certaines versions ce paramètre est indispensable, donc dans le doute, ça ne mange pas de pain.

soit dit en passant, tu connais bien Perl ? quel(s) langage(s) utilises-tu ?
Non, pas du tout. Et pour le langage, je n'en maîtrise et connais aucun, juste de bonnes bases en shell bash.

Dénigrer un langage tel que Perl est d'assez mauvais goût.

open(F, "bio.txt");  
open(G, ">sortie.txt");  
while (<F>) {  
  if (/^.+? Y [\d.]+ Signal.+\r?\n?/) {  
    print G;  
  }  
}  

N'est pas plus illisible que ton code.

De plus, sur les données présentées, Perl s'exécute 5 fois plus vite, en rajoutant le contrôle d'erreurs et la fermeture des fichiers (c'est en option en Python ?) :

$ cat tri.pl  
#!/usr/bin/perl  

open(F, "bio.txt") or die $!;  
open(G, ">sortie.txt") or die $!;  
while (<F>) {  
  if (/^.+? Y [\d.]+ Signal.+\r?\n?/) {  
    print G;  
  }  
}  
close(F);  
close(G);  


$ cat tri1.py  
#!/usr/bin/python  

import re  

regx = re.compile(' Y [\d.]+ Signal')  

with open('bio.txt','r') as f:  
    generY = (line for line in f if regx.search(line))  
    with open('sortie.txt','w') as g:  
        g.writelines(generY)  


$ cat tri2.py  
#!/usr/bin/python  

import re  

regx = re.compile('^.+? Y [\d.]+ Signal.+\r?\n?',re.MULTILINE)  

with open('bio.txt','r') as f:  
    lu = f.read()  
    with open('sortie.txt','w') as g:  
        g.writelines(regx.findall(lu))  


$ time ./tri.pl  

real    0m0.002s  
user    0m0.004s  
sys     0m0.000s  
$ time ./tri1.py  

real    0m0.012s  
user    0m0.012s  
sys     0m0.000s  
$ time ./tri2.py  

real    0m0.011s  
user    0m0.008s  
sys     0m0.004s  
$

Avec Perl 5.10.1, Python 2.6.6, sur une Debian i486-linux.

... je te laisse imaginer le résultat avec 35 GB de données.


Dal

Salut Dal

Sur mon ordinateur, le code suivant correpsondant à tri1 tourne en 0.0018 secondes:

import re
from time import clock
from os import remove

te = clock()

try:
    regx = re.compile(' Y [\d.]+ Signal')  

    with open('bio.txt','r') as f:  
        generY = (line for line in f if regx.search(line))  
        with open('sortie.txt','w') as g:  
            g.writelines(generY)
except:
    pass

print clock()-te

raw_input("pause")

Le code similaire correspondant à tri2 tourne en 0.0024 secondes


try...except est pour avoir l'équivalent de die en Perl
Le statement with ferme les fichiers de façon propre, y compris quand il y a des erreurs qui surviennent


Mais ces temps ne veulent rien dire parce que mon processeur est un Celeron 2.7 GHz tandis que les vieux processeur i486 ont eu une fréquence max de 100 MHz d'après ce que je vois sur l'article "Intel 80486" en anglais de Wikipedia

Je vais essayer d'installer Perl sur mon ordinateur pour faire tourner ton code.
Mais pourrais tu donner le vrai code complet, je ne vois pas dans ton code les instructions qui permettent de sortir les temps


Que sont les temps real, user, sys, au passage stp ?

Salut heyquem,

Les mesures sont faites au moyen de la commande "time", qui est une commande POSIX (présente sur les systèmes de type Unix) dont le fonctionnement est décrit à la page de manuel :

https://linux.die.net/man/1/time

Le code complet de mon script Perl est donné (à la suite de cat tri.pl, "cat" étant une autre commande standard permettant l'affichage du contenu d'un fichier texte).

Le même référentiel de mesure est donc utilisé pour mon script et tes deux précédents scripts.

Ma machine n'est pas un 486. Debian i486-linux se réfère au système d'exploitation Linux Debian avec un noyau compilé pour des processeurs compatibles avec i486. C'est une machine que j'ai assemblée il y a environ un an, avec un processeur Intel bon marché et 2 Go de mémoire (je ne sais pas te dire quel processeur, ni sa fréquence).

Cela dit, ce qui compte, me semble-t-il, c'est que la mesure est faite par le même procédé.

S'agissant de "l'illisibilité", c'est une affaire de style de programmation et de subjectivité, mais, pour moi, mon code n'est pas plus "illisible" que ton code.


Dal

J'ai installé Perl sur mon ordinateur et après pas mal de difficultés j'ai réussi à faire tourner le code suivant:

code TRI

use strict;
use warnings;
use Time::HiRes qw(gettimeofday tv_interval);

my $t0_t1;
my $t1;
my $t0 = gettimeofday();

open(F, "bio.txt") or die $!;  
open(G, ">sortie.txt") or die $!;  
while (<F>) {  
  if (/^.+? Y [\d.]+ Signal.+\r?\n?/) {  
    print G;  
  }  
}  
close(F);  
close(G); 

$t1 = gettimeofday();


print "t0 = $t0\n";
print "t1 = $t1\n";

$t0_t1 = $t1-$t0;;


print "Execution time: $t0_t1 \n";

J'ai aussi fait tourner les codes Python suivants



code TRI1

import re
from time import clock
from os import remove
from os.path import isfile

if isfile('sortie.txt'):
    remove('sortie.txt')
    
te = clock()

try:
    regx = re.compile(' Y [\d.]+ Signal')  

    with open('bio.txt','r') as f:  
        generY = (line for line in f if regx.search(line))  
        with open('sortie.txt','w') as g:  
            g.writelines(generY)
except:
    pass

print clock()-te

raw_input("pause")

code TRI3

import re
from time import clock
from os import remove
from os.path import isfile

if isfile('sortie.txt'):
    remove('sortie.txt')
    
te = clock()

try:
    regx = re.compile(' Y [\d.]+ Signal')  

    with open('bio.txt','r') as f,open('sortie.txt','w') as g:  
        g.writelines(line for line in f if regx.search(line))
except:
    pass

print clock()-te

raw_input("pause")

Pour chaque code, je l'ai exécuté plusieurs fois et j'ai pris le temps minimal car d'une fois sur l'autre il y a des temps d'exécution variables. La répartition des temps d'exécution d'un code donné doit être du genre courbe de Gauss. Or j'ai lu quelque part que pour apprécier la vitesse d'un programme, c'est le temps minimal jusqu'où il peut descendre qui est vraiment significatif.

AInsi ai-je obtenu:

Perl TRI 0.001373 secondes
Python TRI1 0.001695 secondes (vu deux fois)
Python TRI3 0,001968 secondes

Cependant les valeurs 0.001755 et deux fois 0.001695 que j'ai vues pour TRI1 me semblent bizarres car toutes les autres valeurs étaient au dessus de 0.001826 et en fait le temps de TRI1 avait du mal à être en dessous de 0.001950.
Aussi je prends 0.001950 pour temps mini de TRI1

Quant au code Perl, il est certes descendu à 0.001373 et 0.001410 mais il avait du mal à être au dessous de 0.001450.
Donc là aussi, par méfiance sur les résultats qui me paraissent trop en dessous de la moyenne (bien que ce soit normal d'observer de telles valeurs si c'est une courbe de Gauss), je prends 0.001450 secondes comme temps mini du code Perl TRI

La comparaison des codes est donc plutôt sur:
TRI 0.001450 secondes
TRI1 0.001950 secondes

Ce qui donne le code Python tournant en 35% de temps en plus que le code Perl, soit un rapport TRI1/TRI = 1.35

Ce n'est quand même pas le rapport 3 si on prend les temps 'user', ou 6 si on prend les temps 'real' que donnent tes résultats.

Perl est donc plus rapide sur ce coup là.
Mais il faut noter que le volume de données est très faible et que les temps passés en opérations d'ouverture, véruification, fermeture de fichiers est proportionnellement important dans ce cas par rapport au traitement des données proprement dit.
Je testerai plus tard ce qui se passe avec des fichier plus gros.




D'autre part, bien sûr c'est le reproche qu'on fait à Python, d'être plus lent que d'autres langages. Certes il est plus lent à l'exécution que Perl, C, C++. Encore faudrait il examiner très sérieusement quelle est l'importance de cette lenteur pour vraiment savoir de quoi on parle. Je n'ai jamais vu beaucoup de comparatifs sur des programmes importants, il y a des rengaines qui se répètent sans que les choses soient vraiment vérifiées.

Mais c'est quasiment le seul reproche qu'on peut faire à Python. Je ne me souviens pas avoir vu d'autres reproches sur Python exprimés de façon aussi aigue que ceux d'autres langages, par exemple l'illisibilité de Perl, la complexité de C++, l'obésité de Java, le laxisme de PHP etc....

Ce qu'il faut mettre en balance c'est l'inconvénient de l'exécution (à peine) plus lente de Python par rapport aux inconvénients des autres langages.
Est-ce qu'il vaut mieux passer 10 fois plus de temps en développement et beaucoup de difficultés à relire et maintenir des codes en C++ ou Perl, pour avoir la satisfaction de gagner 2 secondes à tout casser pour certaines appliactions alors même que la rapidité d'exécution n'est pas un critère déterminant ? C'est à chacun de décider ce qui lui pèse le moins.
Personnellement, modifier un fichier en 1,45 millisecondes plutôt qu'en 1,95 millisecondes, je pense qu'on s'en fout complétement, parce qu'après ça on va passer 25 minutes devant la machine à café.
Et pour ce qui est de 35 GB de données, je demande à voir la différence de temps.

"il y a des rengaines qui se répètent sans que les choses soient vraiment vérifiées"

oui, c'est certain :-)


Dal