Discussion :

[pontarose]

bonjour,

J'aimerais connaître le nombre de A dans ma séquence

>scaf
ATTTTA
GGTTGA
>scaf
CGGA
GTC

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
#!/usr/bin/perl
 
use strict;
use Bio::SeqIO;
my $file = 'test.fa';
 
my $in  = Bio::SeqIO->new(-file => $file , '-format' => 'fasta');
 
my %hash;
while ( my $seq = $in->next_seq() ){         
    $hash{$seq->seq} = $seq->primary_id ;
}
 
 
foreach my $seq (keys %hash){   
    print ">$hash{$seq}\n$seq\t: ".length($seq)."\n";                        
    if($hash{$seq} =~ /A/){
      #my $nombre = ;
    }
    print ">$hash{$seq}\t ".length($seq)."A=$hash{$A}\n";                           
}

en fait je bloque pour déterminer le nombre de A

[djibril]

ça t'aidera.

[lukeabate]

bonjour,
je me permet de poster une question n'étant pas trop adéquate à cette discussion mais vu qu'il y a la notion compter, avec un fichier fasta donc domaine bio mol, je poste ici

alors je suis tout d'abord assez novice en perl (suivi récemment une formation de quelques jours sur perl, entre d'autres choses)

alors je voudrais, à partir d'un fichier fasta, seulement retirer les infos me disant :
pour telle taille, tu as x séquences de même longueur
j'ai déjà un peu traficoter le fichier d'origine pour me le mettre sous la forme suivante ('nom_seq' \t 'taille' \t 'seq' \n) (j'ai linéarisé la sequence)

>seq1 52 ATTACGGTAGGTC...
>seq2 64 ATGGAACCCGATTGCAGATGAC...
etc.

ce qui me permet de faciliter la chose (je me sert de cette pagination pour sélectionner les seq d'une certaine taille)

alors voici ce que j'ai pondu (avec fierté)

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
#script pour compter l'occurence des différentes tailles des séquences
 
open (TMP, "SeqNumber_$ARGV[0].txt");
$compteur=0;
$length=0;
while ($ligne=<TMP>) {
  @tbl=split('\t', $ligne);
  $compteur++;
  $length[$compteur]=$tbl[1];      #assigne les valeurs tailles dans les variables $length selon n° de ligne
}
close (TMP);
 
open (TMP, "SeqNumber_$ARGV[0].txt");
while ($ligne=<TMP>) {                     #ici compte si egale en comparant le fichier, à chaque ligne, avec l'ensemble des valeurs assignées
  $nb=0;                                   #mais pas super car assez long a générer et répétitions !!!
  @tbl=split('\t', $ligne);
  for ($i=0; $i<=$compteur; $i++){
    if ($length[$i]==$tbl[1]){
      $nb=$nb+1;
    }
  }
  print TMPlog "$tbl[1]\t$nb\n";
}
 
close (TMP);

bon y manque le début mais n'étant pas relatif à ce processus (TMPlog déjà créé plus haut, ici non vu)

ça me génère ce fichier

20 85
20 85
45 33
280 501
45 33
56 9
281 6203
280 501
20 85
45 33
43 10
20 85
282 558
20 85
282 558
283 189
20 85
281 6203
20 85
20 85

(normalement y a tabulation)
On remarque que pour une taille de 281pb il y a 6203 seq, mais c'est répété pour chq seq, et je ne voudrais qu'une seule fois par taille comme suite :

20 85
45 33
280 501
45 33
56 9
281 6203
43 10
282 558
283 189

l'ordre m'importe peu mais ça serait sympa de me dire cmment y arriver juste pour savoir (ordre croissant decroissant)

bon après je pense que c'est pas la bonne logique que j'ai utilisé pour essayé de faire cela, j'aimerais également un processus qui soit un peu plus rapide.

merci bien

[Philou67430]

Je t'invite plutôt à utiliser une table de hashage.

Voici ce que cela pourrait donner en uniligne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

perl -e 'my (undef, $size) = split /\t/;$sizes{$size}++; END { print "Size $_: $sizes{$_} foreach keys %sizes' < sequence_file.txt

[lukeabate]

tu m'en bouche un coin

je ne sais pas comment utiliser cela, mais va regarder ce qu'est une table de hashage.

@+

edit: merci

[SonyBlack]

Héhé, moi aussi j'aimerais bien résumer mes scripts en une ligne

@u plaisir

[Philou67430]

Pour faire simple, une table de hachage, c'est un tableau dont l'indice n'est pas forcément numérique. On appelle l'indice une clé, et comme pour un tableau standard, chaque emplacement (chaque clé) est unique.

Lorsque l'on utilise une clé numérique pour une table de hashage, la différence avec le tableau normal, c'est que l'allocation des entrées dans la table ne dépend pas de la valeur de l'indice.
Imaginons qu'il y ait une taille de séquence de 100000. Avec ton affectation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$array[$length] = ...;

Tu vas créer ou agrandir le tableau @array jusqu'à au moins une taille de 100000 éléments.

En écrivant cela à l'aide d'une table de hashage :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

$array{$length} = ...;

L'allocation ne dépendra pas de $length (elle dépendra du nombre de clé déjà enregistrées.
Par ailleurs, la recherche d'une clé dans une table de hashage est rapide, car elle utilise une technique de tri par clé de hashage pour enregistrer les données (plutôt qu'un enregistrement séquentiel comme un tableau normal).

Si tu souhaites d'autres explications, n'hésite pas.