生物信息学入门：Biopython功能概览与教程

需积分: 9 188 浏览量更新于2024-07-17 收藏 851KB PDF 举报

BioPython教程是一个面向生物信息学的开源Python工具包，由国际开发团队维护。它旨在通过创建高质量、可重用的模块和脚本，使Python编程在生物信息学领域变得简单易用。该教程涵盖了广泛的生物信息学功能，包括解析多种文件格式（如BLAST输出、ClustalW、FASTA、GenBank等），访问在线数据库服务（如NCBI的Entrez和PubMed），与常用生物信息学程序交互（如独立的BLAST和ClustalW），以及处理序列操作（如翻译、转录）和数据分类（如kNN、朴素贝叶斯和支持向量机）。此外，BioPython还提供了GUI工具进行基本的序列操作，文档和帮助资源丰富，包括在线wiki文档、网站和邮件列表。教程首先介绍了安装方法，并强调了其在处理各种任务中的实用性。例如，它指导用户如何快速入门，包括使用BioPython进行序列文件的解析，如简单的FASTA和GenBank文件。对于复杂的文件格式，BioPython提供了细致的支持，如详细讲解如何处理不同的序列文件格式，如反向互补和转录/翻译过程。此外，教程还深入探讨了序列对象的特性，如它们像字符串一样可以进行切割、拼接，以及对核苷酸序列的特殊处理，包括支持可变序列对象。对于数据库连接，BioPython允许用户与生物数据库无缝对接，如利用其API访问NCBI的BLAST服务和ExPASy的蛋白质数据库资源。最后，教程鼓励用户不断学习和探索，提供了一个引导用户下一步发展的框架，以便他们能够根据自己的需求深化对BioPython的理解和应用。这个教程不仅包含了丰富的功能介绍，而且通过实例和实践，帮助读者掌握如何有效地利用BioPython进行生物信息学分析，是Python生物信息学入门者和进阶者的宝贵资源。

Note that using the Bio.SeqUtils.GC() function should automatically cope with mixed case sequences and

the ambiguous nucleotide S which means G or C.

Also note that just like a normal python string, the Seq object is in some ways “read-only”. If you need

to edit your sequence, for example simulating a point mutation, look at the Section 3.10 below which talks

about the MutableSeq object.

3.3 Slicing a sequence

A more complicated example, let’s get a slice of the sequence:

>>> from Bio.Seq import Seq

>>> from Bio.Alphabet import IUPAC

>>> my_seq = Seq("GATCGATGGGCCTATATAGGATCGAAAATCGC", IUPAC.unambiguous_dna)

>>> my_seq[4:12]

Seq(’GATGGGCC’, IUPACUnambiguousDNA())

Two things are interesting to note. First, this follows the normal conventions for python strings. So the

ﬁrst element of the sequence is 0 (which is normal for computer science, but not so normal for biology).

When you do a slice the ﬁrst item is included (i.e. 4 in this case) and the last is excluded (12 in this case),

which is the way things work in python, but of course not necessarily the way everyone in the world would

expect. The main goal is to stay consistent with what python does.

The second thing to notice is that the slice is performed on the sequence data string, but the new object

produced is another Seq object which retains the alphabet information from the original Seq object.

Also like a python string, you can do slices with a start, stop and stride (the step size, which defaults to

one). For example, we can get the ﬁrst, second and third codon positions of this DNA se quence:

>>> my_seq[0::3]

Seq(’GCTGTAGTAAG’, IUPACUnambiguousDNA())

>>> my_seq[1::3]

Seq(’AGGCATGCATC’, IUPACUnambiguousDNA())

>>> my_seq[2::3]

Seq(’TAGCTAAGAC’, IUPACUnambiguousDNA())

Another stride trick you might have seen with a python string is the use of a -1 stride to reverse the

string. You c an do this with a Seq object too:

>>> my_seq[::-1]

Seq(’CGCTAAAAGCTAGGATATATCCGGGTAGCTAG’, IUPACUnambiguousDNA())

3.4 Turning Seq objects into st ring s

If you really do just need a plain string, for example to write to a ﬁle, or insert into a database, then this is

very easy to get:

>>> str(my_seq)

’GATCGATGGGCCTATATAGGATCGAAAATCGC’

Since calling str() on a Seq object returns the full sequence as a string, you often don’t actually have

to do this conversion explicitly. Python does this automatically with a print statement:

>>> print my_seq

GATCGATGGGCCTATATAGGATCGAAAATCGC

You can also use the Seq object directly with a %s placeholder when using the python string formatting

or interpolation operator (%):

>>> fasta_format_string = ">Name\n%s\n" % my_seq

>>> print fasta_format_string

>Name

GATCGATGGGCCTATATAGGATCGAAAATCGC

This line of code constructs a simple FASTA format record (without worrying about line wrapping). Reading

and writing FASTA format sequence ﬁles is covered in Chapter 4, in particular Section 4.4.3 describes a neat

way to get a FASTA formatted string.

NOTE: If you are using Biopython 1.44 or older, using str(my_seq) will give just a truncated repre-

sentation. Instead use my_seq.tostring() (which is still available in the current Biopython releases for

backwards compatibility):

>>> my_seq.tostring()

’GATCGATGGGCCTATATAGGATCGAAAATCGC’

3.5 Concatenating or adding sequences

Naturally, you can in principle add any two Seq objects together - just like you can with python strings

to concatenate them. However, you can’t add sequences with incompatible alphabets, such as a protein

sequence and a DNA sequence:

>>> protein_seq + dna_seq

Traceback (most recent call last):

File "<stdin>", line 1, in ?

File "/usr/local/lib/python2.4/site-packages/Bio/Seq.py", line 42, in __add__

raise TypeError, ("incompatable alphabets", str(self.alphabet),

TypeError: (’incompatable alphabets’, ’IUPACProtein()’, ’IUPACUnambiguousDNA()’)

If you really wanted to do this, you’d have to ﬁrst give both sequences generic alphabets:

>>> from Bio.Alphabet import generic_alphabet

>>> protein_seq.alphabet = generic_alphabet

>>> dna_seq.alphabet = generic_alphabet

>>> protein_seq + dna_seq

Seq(’EVRNAKACGT’, Alphabet())

Here is an example of adding a generic nucleotide sequence to an unambiguous IUPAC DNA sequence,

resulting in an ambiguous nucleotide sequence:

>>> from Bio.Seq import Seq

>>> from Bio.Alphabet import generic_nucleotide

>>> from Bio.Alphabet import IUPAC

>>> nuc_seq = Seq("GATCGATGC", generic_nucleotide)

>>> dna_seq = Seq("ACGT", IUPAC.unambiguous_dna)

>>> nuc_seq

Seq(’GATCGATGC’, NucleotideAlphabet())

>>> dna_seq

Seq(’ACGT’, IUPACUnambiguousDNA())

>>> nuc_seq + dna_seq

Seq(’GATCGATGCACGT’, NucleotideAlphabet())

3.6 Nucleotide sequences and (reverse) complements

For nucleotide sequences, you can easily obtain the complement or reverse complement of a Seq object using

its built-in methods:

>>> from Bio.Seq import Seq

>>> from Bio.Alphabet import IUPAC

>>> my_seq = Seq("GATCGATGGGCCTATATAGGATCGAAAATCGC", IUPAC.unambiguous_dna)

>>> my_seq

Seq(’GATCGATGGGCCTATATAGGATCGAAAATCGC’, IUPACUnambiguousDNA())

>>> my_seq.complement()

Seq(’CTAGCTACCCGGATATATCCTAGCTTTTAGCG’, IUPACUnambiguousDNA())

>>> my_seq.reverse_complement()

Seq(’GCGATTTTCGATCCTATATAGGCCCATCGATC’, IUPACUnambiguousDNA())

In all of these operations, the alphabet property is maintained. This is very useful in case you accidentally

end up trying to do something weird like take the (reverse)complement of a protein sequence:

>>> from Bio.Seq import Seq

>>> from Bio.Alphabet import IUPAC

>>> protein_seq = Seq("EVRNAK", IUPAC.protein)

>>> protein_seq.complement()

Traceback (most recent call last):

File "<stdin>", line 1, in ?

File "/usr/local/lib/python2.4/site-packages/Bio/Seq.py", line 108, in complement

raise ValueError, "Proteins do not have complements!"

ValueError: Proteins do not have complements!

3.7 Transcription

Before talking about transcription, I want to try and clarify the strand issue. Consider the following (made

up) stretch of double stranded DNA which encodes a short peptide:

DNA coding strand (aka Crick strand, strand +1)

5’ ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG 3’

|||||||||||||||||||||||||||||||||||||||

3’ TACCGGTAACATTACCCGGCGACTTTCCCACGGGCTATC 5’

DNA template strand (aka Watson strand, strand −1)

Transcription

↓

5’ AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG 3’

Single stranded messenger RNA

The actual biological transcription process works from the template strand, doing a reverse complement

(TCAG → CUGA) to give the mRNA. However, in Biopython and bioinformatics in general, we typically

work directly with the coding strand because this means we can get the mRNA sequence just by switching

T → U.

Now let’s actually get down to doing a transcription in Biopython. First, let’s create Seq objects for the

coding and template DNA strands:

>>> from Bio.Seq import Seq

>>> from Bio.Alphabet import IUPAC

>>> coding_dna = Seq("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG", IUPAC.unambiguous_dna)

>>> coding_dna

Seq(’ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG’, IUPACUnambiguousDNA())

>>> template_dna = coding_dna.reverse_complement()

>>> template_dna

Seq(’CTATCGGGCACCCTTTCAGCGGCCCATTACAATGGCCAT’, IUPACUnambiguousDNA())

These should match the ﬁgure above - remember by convention nucleotide sequences are normally read from

the 5’ to 3’ direction, while in the ﬁgure the template strand is shown reversed.

Now let’s transcribe the coding strand into the corresponding mRNA, using the Seq object’s built in

transcribe method:

>>> coding_dna

Seq(’ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG’, IUPACUnambiguousDNA())

>>> messenger_rna = coding_dna.transcribe()

>>> messenger_rna

Seq(’AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG’, IUPACUnambiguousRNA())

As you can see, all this does is switch T → U, and adjust the alphabet.

If you do want to do a true biological transcription starting with the template strand, then this becomes

a two-step process:

>>> template_dna.reverse_complement().transcribe()

Seq(’AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG’, IUPACUnambiguousRNA())

The Seq object also includes a back-transcription method for going from the mRNA to the coding strand

of the DNA. Again, this is a simple U → T substitution and associated change of alphabet:

>>> from Bio.Seq import Seq

>>> from Bio.Alphabet import IUPAC

>>> messenger_rna = Seq("AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG", IUPAC.unambiguous_rna)

>>> messenger_rna

Seq(’AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG’, IUPACUnambiguousRNA())

>>> messenger_rna.back_transcribe()

Seq(’ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG’, IUPACUnambiguousDNA())

Note: The Seq object’s transcribe and back_transcribe methods are new in Biopython 1.49. For

older releases you would have to use the Bio.Seq module’s function instead, see Section

3.11.

3.8 Translation

Sticking with the same example discussed in the transcription section ab ove, now let’s translate this mRNA

into the corresponding protein sequence - again taking advantage of one of the Seq object’s biological meth-

ods:

>>> from Bio.Seq import Seq

>>> from Bio.Alphabet import IUPAC

>>> messenger_rna = Seq("AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG", IUPAC.unambiguous_rna)

>>> messenger_rna

Seq(’AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG’, IUPACUnambiguousRNA())

>>> messenger_rna.translate()

Seq(’MAIVMGR*KGAR*’, HasStopCodon(IUPACProtein(), ’*’))

You can also translate directly from the coding strand DNA sequence:

>>> from Bio.Seq import Seq

>>> from Bio.Alphabet import IUPAC

>>> coding_dna = Seq("ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG", IUPAC.unambiguous_dna)

>>> coding_dna

Seq(’ATGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG’, IUPACUnambiguousDNA())

>>> coding_dna.translate()

Seq(’MAIVMGR*KGAR*’, HasStopCodon(IUPACProtein(), ’*’))

You should notice in the above protein sequences that in addition to the end stop character, there is

an internal stop as well. This was a deliberate choice of example, as it gives an excuse to talk about some

optional arguments, including diﬀerent translation tables (Genetic Codes).

The translation tables available in Biopython are based on those from the NCBI (see the next section of

this tutorial). By default, translation will use the standard genetic code (NCBI table id 1). Suppose we are

dealing with a mitochondrial sequence. We need to tell the translation function to use the relevant genetic

code instead:

>>> coding_dna.translate(table="Vertebrate Mitochondrial")

Seq(’MAIVMGRWKGAR*’, HasStopCodon(IUPACProtein(), ’*’))

You can also specify the table using the NCBI table number which is shorter, and often included in the

feature annotation of GenBank ﬁles:

>>> coding_dna.translate(table=2)

Seq(’MAIVMGRWKGAR*’, HasStopCodon(IUPACProtein(), ’*’))

Now, you may want to translate the nucleotides up to the ﬁrst in frame stop codon, and then stop (as

happ e ns in nature):

>>> coding_dna.translate()

Seq(’MAIVMGR*KGAR*’, HasStopCodon(IUPACProtein(), ’*’))

>>> coding_dna.translate(to_stop=True)

Seq(’MAIVMGR’, IUPACProtein())

>>> coding_dna.translate(table=2)

Seq(’MAIVMGRWKGAR*’, HasStopCodon(IUPACProtein(), ’*’))

>>> coding_dna.translate(table=2, to_stop=True)

Seq(’MAIVMGRWKGAR’, IUPACProtein())

Notice that when you use the to_stop argument, the stop codon itself is not translated - and the stop symbol

is not included at the end of your protein sequence.

Finally, you can even specify the stop symbol if you don’t like the default asterisk:

>>> coding_dna.translate(table=2, stop_symbol="@")

Seq(’MAIVMGRWKGAR*’, HasStopCodon(IUPACProtein(), ’@’))

Note: The Seq object’s translate method is new in Biopython 1.49. For older releases you would have

to use the Bio.Seq module’s translate function instead, see Section 3.11.

3.9 Translation Tables

In the previous sections we talked about the Seq object translation method (and mentioned the equivalent

function in the Bio.Seq module – see Sec tion 3.11). Internally these use codon table objects derived from

the NCBI information at ftp://ftp.ncbi.nlm.nih.gov/entrez/misc/data/gc.prt.

As before, let’s just focus on two choices: the Standard translation table, and the translation table for

Vertebrate Mitochondrial DNA.

剩余141页未读，继续阅读

drjiachen

粉丝: 172
资源: 2138

生物信息学入门：Biopython功能概览与教程

Biopython 教程与手册

biopython中文教程

Biopython Tutorial and Cookbook.pdf.pdf

soatest5.5_Tutorial.pdf&soatest_Tutorial.pdf

Deep_Learning_Tutorial_0.1.pdf.pdf

Firewall_tutorial.pdf

Geocoding_tutorial.pdf

jpa_tutorial.pdf

FFT_tutorial_NI.pdf

TCP_Programming_Tutorial.pdf

最新资源