Obtendo o arquivo fasta correspondido

2

list.txt :

58759__len__2903
58759__len__2903
673957__len__1655
673957__len__1655
3566454__len__1744

seq.fasta :

>58759__len__2903
TTTTCCGTAGAGGAGATCCCTATTTTTAGGTTTGTAAGAGATCATTTT
>67777__len__2978
TTTTTAGGTTTGTAAGACCGTAGAG
>673957__len__1655
CCCTATTTTTAGGTTTGTAAGGTTTGTAAGACCGTAGAG
>3566454__len__1744
GGTTTGTAAGACCGTAGAGGGTTTGTAAGACCGTAGAG

output.fasta :

>58759__len__2903
TTTTCCGTAGAGGAGATCCCTATTTTTAGGTTTGTAAGAGATCATTTT
>673957__len__1655
CCCTATTTTTAGGTTTGTAAGGTTTGTAAGACCGTAGAG
>3566454__len__1744
GGTTTGTAAGACCGTAGAGGGTTTGTAAGACCGTAGAG

Corresponda a linha de list.txt (se duplicar linha, use somente linha exclusiva) para seq.fasta e extraia o arquivo FASTA conforme mostrado no arquivo de saída.

    
por jack 22.09.2014 / 10:57

1 resposta

7

O caso simples que você mostra é trivial. As suas sequências nunca são mais do que uma única linha, pelo que pode simplesmente utilizar grep para procurar cada um dos seus IDs e a linha depois deles:

grep -Fwf list.txt -A 1  seq.fasta | grep -v '^--$'  > out.fasta

O grep -v '^--$' simplesmente filtra as linhas com -- que grep adiciona entre grupos de linhas de saída ao usar a opção -A .

Para evitar os enganos, você pode passar sua lista por meio da classificação (GNU):

grep -Fwf <(sort -u list.txt) -A 1  seq.fasta | grep -v '^--$'  > out.fasta

As bandeiras usadas são:

   -f FILE, --file=FILE
          Obtain  patterns  from  FILE,  one  per  line.   The  empty file
          contains zero patterns, and therefore matches nothing.   (-f  is
          specified by POSIX.)
   -w, --word-regexp
          Select  only  those  lines  containing  matches  that form whole
          words.  The test is that the matching substring must  either  be
          at  the  beginning  of  the  line,  or  preceded  by  a non-word
          constituent character.  Similarly, it must be either at the  end
          of  the  line  or  followed by a non-word constituent character.
          Word-constituent  characters  are  letters,  digits,   and   the
          underscore.
   -F, --fixed-strings
          Interpret PATTERN as a  list  of  fixed  strings,  separated  by
          newlines,  any  of  which is to be matched.  (-F is specified by
          POSIX.)
   -A NUM, --after-context=NUM
          Print NUM  lines  of  trailing  context  after  matching  lines.
          Places   a  line  containing  a  group  separator  (--)  between
          contiguous groups of matches.  With the  -o  or  --only-matching
          option, this has no effect and a warning is given.

No entanto, na maioria dos casos, suas seqüências serão várias linhas e isso não será suficiente. Se você fizer esse tipo de coisa com frequência, sugiro instalar o conjunto de ferramentas exonerate . Eles são geralmente extremamente úteis para o trabalho de bioinformática e incluem uma boa ferramenta chamada fastafetch que é projetada para fazer exatamente o que você quer:

  1. Instale o pacote exonerado. Isso está nos repositórios dos sistemas baseados em Debian, e também está disponível em aqui .

    sudo apt-get install exonerate
    
  2. Crie um índice para o seu arquivo fasta. Isso é usado para a rápida recuperação de seqüências.

    fastaindex seq.fasta seq.idx 
    
  3. Extraia suas seqüências:

    $ fastafetch -f seq.fasta -i seq.idx -Fq <(sort -u list.txt )
    >3566454__len__1744
    GGTTTGTAAGACCGTAGAGGGTTTGTAAGACCGTAGAG
    >58759__len__2903
    TTTTCCGTAGAGGAGATCCCTATTTTTAGGTTTGTAAGAGATCATTTT
    >673957__len__1655
    CCCTATTTTTAGGTTTGTAAGGTTTGTAAGACCGTAGAG
    

Como uma nota lateral, eu escrevi um script que pode fazer isso e um pouco mais. Pode levar uma ou mais listas de IDs de entrada e extrairá as seqüências correspondentes de um arquivo multi-fasta. Pode imprimir em STDOUT ou criar um arquivo para cada lista de entrada. Você pode encontrá-lo aqui .

    
por 22.09.2014 / 13:22