Biopython - Kurzanleitung
Biopython ist das größte und beliebteste Bioinformatik-Paket für Python. Es enthält eine Reihe verschiedener Untermodule für allgemeine Bioinformatikaufgaben. Es wird von Chapman und Chang entwickelt und hauptsächlich in Python geschrieben. Es enthält auch C-Code zur Optimierung des komplexen Berechnungsteils der Software. Es läuft unter Windows, Linux, Mac OS X usw.
Grundsätzlich handelt es sich bei Biopython um eine Sammlung von Python-Modulen, die Funktionen für DNA-, RNA- und Proteinsequenzoperationen wie die umgekehrte Komplementierung eines DNA-Strings, das Auffinden von Motiven in Proteinsequenzen usw. bereitstellen. Es bietet viele Parser zum Lesen aller wichtigen genetischen Datenbanken wie GenBank, SwissPort, FASTA usw. sowie Wrapper / Interfaces zum Ausführen anderer beliebter Bioinformatik-Software / -Tools wie NCBI BLASTN, Entrez usw. in der Python-Umgebung. Es hat Geschwisterprojekte wie BioPerl, BioJava und BioRuby.
Eigenschaften
Biopython ist portabel, klar und hat eine leicht zu erlernende Syntax. Einige der wichtigsten Merkmale sind unten aufgeführt -
Interpretiert, interaktiv und objektorientiert.
Unterstützt die Formate FASTA, PDB, GenBank, Blast, SCOP, PubMed / Medline und ExPASy.
Option zum Umgang mit Sequenzformaten.
Werkzeuge zur Verwaltung von Proteinstrukturen.
BioSQL - Standardsatz von SQL-Tabellen zum Speichern von Sequenzen sowie Funktionen und Anmerkungen.
Zugriff auf Online-Dienste und Datenbanken, einschließlich NCBI-Dienste (Blast, Entrez, PubMed) und ExPASY-Dienste (SwissProt, Prosite).
Zugang zu lokalen Diensten, einschließlich Blast, Clustalw, EMBOSS.
Tore
Das Ziel von Biopython ist es, einen einfachen, standardmäßigen und umfassenden Zugang zur Bioinformatik über die Python-Sprache zu ermöglichen. Die spezifischen Ziele des Biopython sind unten aufgeführt -
Bereitstellung eines standardisierten Zugriffs auf Bioinformatik-Ressourcen.
Hochwertige, wiederverwendbare Module und Skripte.
Schnelle Array-Manipulation, die in Cluster-Code, PDB, NaiveBayes und Markov-Modell verwendet werden kann.
Genomdatenanalyse.
Vorteile
Biopython benötigt sehr wenig Code und bietet die folgenden Vorteile:
Bietet einen Microarray-Datentyp, der beim Clustering verwendet wird.
Liest und schreibt Dateien vom Typ Tree-View.
Unterstützt Strukturdaten, die zum Parsen, Darstellen und Analysieren von PDBs verwendet werden.
Unterstützt Journaldaten, die in Medline-Anwendungen verwendet werden.
Unterstützt die BioSQL-Datenbank, die in allen Bioinformatik-Projekten als Standarddatenbank weit verbreitet ist.
Unterstützt die Parserentwicklung durch Bereitstellung von Modulen zum Parsen einer Bioinformatikdatei in ein formatspezifisches Datensatzobjekt oder eine generische Klasse von Sequenzen plus Funktionen.
Klare Dokumentation basierend auf dem Kochbuchstil.
Beispielfallstudie
Lassen Sie uns einige Anwendungsfälle (Populationsgenetik, RNA-Struktur usw.) überprüfen und versuchen zu verstehen, wie Biopython in diesem Bereich eine wichtige Rolle spielt -
Populationsgenetik
Populationsgenetik ist die Untersuchung der genetischen Variation innerhalb einer Population und beinhaltet die Untersuchung und Modellierung von Veränderungen in der Häufigkeit von Genen und Allelen in Populationen über Raum und Zeit.
Biopython bietet das Bio.PopGen-Modul für die Populationsgenetik. Dieses Modul enthält alle notwendigen Funktionen, um Informationen über die klassische Populationsgenetik zu sammeln.
RNA-Struktur
Drei wichtige biologische Makromoleküle, die für unser Leben essentiell sind, sind DNA, RNA und Protein. Proteine sind die Arbeitspferde der Zelle und spielen als Enzyme eine wichtige Rolle. DNA (Desoxyribonukleinsäure) wird als „Blaupause“ der Zelle angesehen. Es enthält alle genetischen Informationen, die erforderlich sind, damit die Zelle wächst, Nährstoffe aufnimmt und sich vermehrt. RNA (Ribonukleinsäure) wirkt als "DNA-Fotokopie" in der Zelle.
Biopython bietet Bio.Sequence-Objekte, die Nukleotide, Bausteine von DNA und RNA darstellen.
In diesem Abschnitt wird erläutert, wie Sie Biopython auf Ihrem Computer installieren. Die Installation ist sehr einfach und dauert nicht länger als fünf Minuten.
Step 1 - Überprüfen der Python-Installation
Biopython wurde für Python 2.5 oder höhere Versionen entwickelt. Daher muss Python zuerst installiert werden. Führen Sie den folgenden Befehl in Ihrer Eingabeaufforderung aus -
> python --versionEs ist unten definiert -
Es zeigt die Version von Python, wenn es richtig installiert ist. Laden Sie andernfalls die neueste Version von Python herunter, installieren Sie sie und führen Sie den Befehl erneut aus.
Step 2 - Installieren von Biopython mit pip
Es ist einfach, Biopython mit pip über die Befehlszeile auf allen Plattformen zu installieren. Geben Sie den folgenden Befehl ein -
> pip install biopythonDie folgende Antwort wird auf Ihrem Bildschirm angezeigt:
Zum Aktualisieren einer älteren Version von Biopython -
> pip install biopython –-upgradeDie folgende Antwort wird auf Ihrem Bildschirm angezeigt:
Nach dem Ausführen dieses Befehls werden die älteren Versionen von Biopython und NumPy (Biopython hängt davon ab) entfernt, bevor die neuesten Versionen installiert werden.
Step 3 - Überprüfen der Biopython-Installation
Jetzt haben Sie Biopython erfolgreich auf Ihrem Computer installiert. Geben Sie den folgenden Befehl auf Ihrer Python-Konsole ein, um zu überprüfen, ob Biopython ordnungsgemäß installiert ist.
Es zeigt die Version von Biopython.
Alternate Way − Installing Biopython using Source
Befolgen Sie die folgenden Anweisungen, um Biopython mithilfe des Quellcodes zu installieren:
Laden Sie die aktuelle Version von Biopython über den folgenden Link herunter: https://biopython.org/wiki/Download
Ab sofort ist die neueste Version biopython-1.72.
Laden Sie die Datei herunter und entpacken Sie die komprimierte Archivdatei, wechseln Sie in den Quellcode-Ordner und geben Sie den folgenden Befehl ein:
> python setup.py buildDadurch wird Biopython aus dem unten angegebenen Quellcode erstellt.
Testen Sie nun den Code mit dem folgenden Befehl:
> python setup.py test
Zum Schluss installieren Sie mit dem folgenden Befehl -
> python setup.py install
Lassen Sie uns eine einfache Biopython-Anwendung erstellen, um eine Bioinformatik-Datei zu analysieren und den Inhalt zu drucken. Dies wird uns helfen, das allgemeine Konzept des Biopythons zu verstehen und wie es auf dem Gebiet der Bioinformatik hilft.
Step 1 - Erstellen Sie zunächst eine Beispielsequenzdatei, "example.fasta", und fügen Sie den folgenden Inhalt ein.
>sp|P25730|FMS1_ECOLI CS1 fimbrial subunit A precursor (CS1 pilin)
MKLKKTIGAMALATLFATMGASAVEKTISVTASVDPTVDLLQSDGSALPNSVALTYSPAV
NNFEAHTINTVVHTNDSDKGVVVKLSADPVLSNVLNPTLQIPVSVNFAGKPLSTTGITID
SNDLNFASSGVNKVSSTQKLSIHADATRVTGGALTAGQYQGLVSIILTKSTTTTTTTKGT
>sp|P15488|FMS3_ECOLI CS3 fimbrial subunit A precursor (CS3 pilin)
MLKIKYLLIGLSLSAMSSYSLAAAGPTLTKELALNVLSPAALDATWAPQDNLTLSNTGVS
NTLVGVLTLSNTSIDTVSIASTNVSDTSKNGTVTFAHETNNSASFATTISTDNANITLDK
NAGNTIVKTTNGSQLPTNLPLKFITTEGNEHLVSGNYRANITITSTIKGGGTKKGTTDKKDie Erweiterung fasta bezieht sich auf das Dateiformat der Sequenzdatei. FASTA stammt aus der Bioinformatik-Software FASTA und hat daher ihren Namen. Das FASTA-Format hat mehrere Sequenzen, die nacheinander angeordnet sind, und jede Sequenz hat ihre eigene ID, ihren eigenen Namen, ihre eigene Beschreibung und die tatsächlichen Sequenzdaten.
Step 2 - Erstellen Sie ein neues Python-Skript, * simple_example.py ", geben Sie den folgenden Code ein und speichern Sie ihn.
from Bio.SeqIO import parse
from Bio.SeqRecord import SeqRecord
from Bio.Seq import Seq
file = open("example.fasta")
records = parse(file, "fasta") for record in records:
print("Id: %s" % record.id)
print("Name: %s" % record.name)
print("Description: %s" % record.description)
print("Annotations: %s" % record.annotations)
print("Sequence Data: %s" % record.seq)
print("Sequence Alphabet: %s" % record.seq.alphabet)Schauen wir uns den Code etwas genauer an -
Line 1Importiert die im Bio.SeqIO-Modul verfügbare Analyseklasse. Das Bio.SeqIO-Modul wird zum Lesen und Schreiben der Sequenzdatei in einem anderen Format verwendet, und die Klasse "parse" wird zum Parsen des Inhalts der Sequenzdatei verwendet.
Line 2Importiert die im Bio.SeqRecord-Modul verfügbare SeqRecord-Klasse. Dieses Modul wird zum Bearbeiten von Sequenzdatensätzen verwendet, und die SeqRecord-Klasse wird zum Darstellen einer bestimmten Sequenz verwendet, die in der Sequenzdatei verfügbar ist.
*Line 3"Importiert die im Bio.Seq-Modul verfügbare Seq-Klasse. Dieses Modul wird zum Bearbeiten von Sequenzdaten verwendet, und die Seq-Klasse wird zum Darstellen der Sequenzdaten eines bestimmten Sequenzdatensatzes verwendet, der in der Sequenzdatei verfügbar ist.
Line 5 öffnet die Datei "example.fasta" mit der regulären Python-Funktion, öffnen Sie.
Line 7 Analysieren Sie den Inhalt der Sequenzdatei und geben Sie den Inhalt als Liste des SeqRecord-Objekts zurück.
Line 9-15 Durchläuft die Datensätze mit Python for Loop und druckt die Attribute des Sequenzdatensatzes (SqlRecord) wie ID, Name, Beschreibung, Sequenzdaten usw. aus.
Line 15 druckt den Sequenztyp mit der Alphabet-Klasse.
Step 3 - Öffnen Sie eine Eingabeaufforderung, gehen Sie zu dem Ordner mit der Sequenzdatei "example.fasta" und führen Sie den folgenden Befehl aus. -
> python simple_example.pyStep 4- Python führt das Skript aus und druckt alle in der Beispieldatei "example.fasta" verfügbaren Sequenzdaten. Die Ausgabe ähnelt dem folgenden Inhalt.
Id: sp|P25730|FMS1_ECOLI
Name: sp|P25730|FMS1_ECOLI
Decription: sp|P25730|FMS1_ECOLI CS1 fimbrial subunit A precursor (CS1 pilin)
Annotations: {}
Sequence Data: MKLKKTIGAMALATLFATMGASAVEKTISVTASVDPTVDLLQSDGSALPNSVALTYSPAVNNFEAHTINTVVHTNDSD
KGVVVKLSADPVLSNVLNPTLQIPVSVNFAGKPLSTTGITIDSNDLNFASSGVNKVSSTQKLSIHADATRVTGGALTA
GQYQGLVSIILTKSTTTTTTTKGT
Sequence Alphabet: SingleLetterAlphabet()
Id: sp|P15488|FMS3_ECOLI
Name: sp|P15488|FMS3_ECOLI
Decription: sp|P15488|FMS3_ECOLI CS3 fimbrial subunit A precursor (CS3 pilin)
Annotations: {}
Sequence Data: MLKIKYLLIGLSLSAMSSYSLAAAGPTLTKELALNVLSPAALDATWAPQDNLTLSNTGVSNTLVGVLTLSNTSIDTVS
IASTNVSDTSKNGTVTFAHETNNSASFATTISTDNANITLDKNAGNTIVKTTNGSQLPTNLPLKFITTEGNEHLVSGN
YRANITITSTIKGGGTKKGTTDKK
Sequence Alphabet: SingleLetterAlphabet()In diesem Beispiel haben wir drei Klassen gesehen: parse, SeqRecord und Seq. Diese drei Klassen bieten den größten Teil der Funktionalität, und wir werden diese Klassen im nächsten Abschnitt lernen.
Eine Sequenz ist eine Reihe von Buchstaben, die verwendet werden, um das Protein, die DNA oder die RNA eines Organismus darzustellen. Es wird durch die Seq-Klasse dargestellt. Die Seq-Klasse wird im Bio.Seq-Modul definiert.
Lassen Sie uns eine einfache Sequenz in Biopython erstellen, wie unten gezeigt -
>>> from Bio.Seq import Seq
>>> seq = Seq("AGCT")
>>> seq
Seq('AGCT')
>>> print(seq)
AGCTHier haben wir eine einfache Proteinsequenz erstellt AGCT und jeder Buchstabe repräsentiert ALanine, GLycin, CYystein und THreonin.
Jedes Seq-Objekt hat zwei wichtige Attribute -
Daten - die tatsächliche Sequenzzeichenfolge (AGCT)
Alphabet - wird verwendet, um die Art der Sequenz darzustellen. zB DNA-Sequenz, RNA-Sequenz usw. Standardmäßig stellt sie keine Sequenz dar und ist generischer Natur.
Alphabet-Modul
Seq-Objekte enthalten das Alphabet-Attribut, um den Sequenztyp, die Buchstaben und mögliche Operationen anzugeben. Es ist im Bio.Alphabet-Modul definiert. Das Alphabet kann wie folgt definiert werden:
>>> from Bio.Seq import Seq
>>> myseq = Seq("AGCT")
>>> myseq
Seq('AGCT')
>>> myseq.alphabet
Alphabet()Das Alphabet-Modul bietet die folgenden Klassen, um verschiedene Arten von Sequenzen darzustellen. Alphabet - Basisklasse für alle Arten von Alphabeten.
SingleLetterAlphabet - Generisches Alphabet mit Buchstaben der Größe eins. Es leitet sich vom Alphabet ab und alle anderen Alphabet-Typen leiten sich davon ab.
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import single_letter_alphabet
>>> test_seq = Seq('AGTACACTGGT', single_letter_alphabet)
>>> test_seq
Seq('AGTACACTGGT', SingleLetterAlphabet())ProteinAlphabet - Generisches Einzelbuchstaben-Proteinalphabet.
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_protein
>>> test_seq = Seq('AGTACACTGGT', generic_protein)
>>> test_seq
Seq('AGTACACTGGT', ProteinAlphabet())NucleotideAlphabet - Generisches Nucleotidalphabet mit einem Buchstaben.
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_nucleotide
>>> test_seq = Seq('AGTACACTGGT', generic_nucleotide) >>> test_seq
Seq('AGTACACTGGT', NucleotideAlphabet())DNAAlphabet - Allgemeines Einzelbuchstaben-DNA-Alphabet.
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_dna
>>> test_seq = Seq('AGTACACTGGT', generic_dna)
>>> test_seq
Seq('AGTACACTGGT', DNAAlphabet())RNAAlphabet - Generisches Einzelbuchstaben-RNA-Alphabet.
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_rna
>>> test_seq = Seq('AGTACACTGGT', generic_rna)
>>> test_seq
Seq('AGTACACTGGT', RNAAlphabet())Das Biopython-Modul Bio.Alphabet.IUPAC bietet grundlegende Sequenztypen, wie sie von der IUPAC-Community definiert wurden. Es enthält die folgenden Klassen -
IUPACProtein (protein) - IUPAC-Proteinalphabet mit 20 Standardaminosäuren.
ExtendedIUPACProtein (extended_protein) - Erweitertes IUPAC-Protein-Einzelbuchstabenalphabet in Großbuchstaben, einschließlich X.
IUPACAmbiguousDNA (ambiguous_dna) - Mehrdeutige IUPAC-DNA in Großbuchstaben.
IUPACUnambiguousDNA (unambiguous_dna) - Eindeutige IUPAC-DNA in Großbuchstaben (GATC).
ExtendedIUPACDNA (extended_dna) - Erweitertes IUPAC-DNA-Alphabet.
IUPACAmbiguousRNA (ambiguous_rna) - Mehrdeutige IUPAC-RNA in Großbuchstaben.
IUPACUnambiguousRNA (unambiguous_rna) - IUPAC-eindeutige RNA in Großbuchstaben (GAUC).
Betrachten Sie ein einfaches Beispiel für die IUPACProtein-Klasse wie unten gezeigt -
>>> from Bio.Alphabet import IUPAC
>>> protein_seq = Seq("AGCT", IUPAC.protein)
>>> protein_seq
Seq('AGCT', IUPACProtein())
>>> protein_seq.alphabetAußerdem stellt Biopython alle Konfigurationsdaten für die Bioinformatik über das Bio.Data-Modul zur Verfügung. Beispielsweise enthält IUPACData.protein_letters die möglichen Buchstaben des IUPACProtein-Alphabets.
>>> from Bio.Data import IUPACData
>>> IUPACData.protein_letters
'ACDEFGHIKLMNPQRSTVWY'Grundoperationen
In diesem Abschnitt werden kurz alle grundlegenden Operationen erläutert, die in der Seq-Klasse verfügbar sind. Sequenzen ähneln Python-Strings. Wir können Python-String-Operationen wie Schneiden, Zählen, Verketten, Suchen, Teilen und Entfernen in Sequenzen ausführen.
Verwenden Sie die folgenden Codes, um verschiedene Ausgaben zu erhalten.
To get the first value in sequence.
>>> seq_string = Seq("AGCTAGCT")
>>> seq_string[0]
'A'To print the first two values.
>>> seq_string[0:2]
Seq('AG')To print all the values.
>>> seq_string[ : ]
Seq('AGCTAGCT')To perform length and count operations.
>>> len(seq_string)
8
>>> seq_string.count('A')
2To add two sequences.
>>> from Bio.Alphabet import generic_dna, generic_protein
>>> seq1 = Seq("AGCT", generic_dna)
>>> seq2 = Seq("TCGA", generic_dna)
>>> seq1+seq2
Seq('AGCTTCGA', DNAAlphabet())Hier sind die beiden oben genannten Sequenzobjekte, seq1, seq2, generische DNA-Sequenzen. Sie können sie also hinzufügen und eine neue Sequenz erstellen. Sie können keine Sequenzen mit inkompatiblen Alphabeten hinzufügen, z. B. eine Proteinsequenz und eine DNA-Sequenz, wie unten angegeben.
>>> dna_seq = Seq('AGTACACTGGT', generic_dna)
>>> protein_seq = Seq('AGUACACUGGU', generic_protein)
>>> dna_seq + protein_seq
.....
.....
TypeError: Incompatible alphabets DNAAlphabet() and ProteinAlphabet()
>>>Um zwei oder mehr Sequenzen hinzuzufügen, speichern Sie sie zuerst in einer Python-Liste, rufen Sie sie dann mit 'for loop' ab und fügen Sie sie schließlich wie unten gezeigt zusammen.
>>> from Bio.Alphabet import generic_dna
>>> list = [Seq("AGCT",generic_dna),Seq("TCGA",generic_dna),Seq("AAA",generic_dna)]
>>> for s in list:
... print(s)
...
AGCT
TCGA
AAA
>>> final_seq = Seq(" ",generic_dna)
>>> for s in list:
... final_seq = final_seq + s
...
>>> final_seq
Seq('AGCTTCGAAAA', DNAAlphabet())Im folgenden Abschnitt werden verschiedene Codes angegeben, um Ausgaben basierend auf der Anforderung zu erhalten.
To change the case of sequence.
>>> from Bio.Alphabet import generic_rna
>>> rna = Seq("agct", generic_rna)
>>> rna.upper()
Seq('AGCT', RNAAlphabet())To check python membership and identity operator.
>>> rna = Seq("agct", generic_rna)
>>> 'a' in rna
True
>>> 'A' in rna
False
>>> rna1 = Seq("AGCT", generic_dna)
>>> rna is rna1
FalseTo find single letter or sequence of letter inside the given sequence.
>>> protein_seq = Seq('AGUACACUGGU', generic_protein)
>>> protein_seq.find('G')
1
>>> protein_seq.find('GG')
8To perform splitting operation.
>>> protein_seq = Seq('AGUACACUGGU', generic_protein)
>>> protein_seq.split('A')
[Seq('', ProteinAlphabet()), Seq('GU', ProteinAlphabet()),
Seq('C', ProteinAlphabet()), Seq('CUGGU', ProteinAlphabet())]To perform strip operations in the sequence.
>>> strip_seq = Seq(" AGCT ")
>>> strip_seq
Seq(' AGCT ')
>>> strip_seq.strip()
Seq('AGCT')In diesem Kapitel werden einige der erweiterten Sequenzfunktionen von Biopython erläutert.
Komplement und Reverse Complement
Die Nukleotidsequenz kann umgekehrt komplementiert werden, um eine neue Sequenz zu erhalten. Die komplementierte Sequenz kann auch umgekehrt komplementiert werden, um die ursprüngliche Sequenz zu erhalten. Biopython bietet zwei Methoden, um diese Funktionalität auszuführen:complement und reverse_complement. Der Code hierfür ist unten angegeben -
>>> from Bio.Alphabet import IUPAC
>>> nucleotide = Seq('TCGAAGTCAGTC', IUPAC.ambiguous_dna)
>>> nucleotide.complement()
Seq('AGCTTCAGTCAG', IUPACAmbiguousDNA())
>>>Hier ermöglicht das komplement () - Verfahren das Komplementieren einer DNA- oder RNA-Sequenz. Die Methode reverse_complement () ergänzt und kehrt die resultierende Sequenz von links nach rechts um. Es ist unten gezeigt -
>>> nucleotide.reverse_complement()
Seq('GACTGACTTCGA', IUPACAmbiguousDNA())Biopython verwendet die von Bio.Data.IUPACData bereitgestellte Variable ambiguous_dna_complement, um die Komplementoperation auszuführen.
>>> from Bio.Data import IUPACData
>>> import pprint
>>> pprint.pprint(IUPACData.ambiguous_dna_complement) {
'A': 'T',
'B': 'V',
'C': 'G',
'D': 'H',
'G': 'C',
'H': 'D',
'K': 'M',
'M': 'K',
'N': 'N',
'R': 'Y',
'S': 'S',
'T': 'A',
'V': 'B',
'W': 'W',
'X': 'X',
'Y': 'R'}
>>>GC-Inhalt
Es wird vorausgesagt, dass die genomische DNA-Basenzusammensetzung (GC-Gehalt) die Genomfunktion und die Artenökologie signifikant beeinflusst. Der GC-Gehalt ist die Anzahl der GC-Nukleotide geteilt durch die Gesamtnukleotide.
Importieren Sie das folgende Modul und führen Sie die folgenden Schritte aus, um den GC-Nukleotidgehalt zu erhalten:
>>> from Bio.SeqUtils import GC
>>> nucleotide = Seq("GACTGACTTCGA",IUPAC.unambiguous_dna)
>>> GC(nucleotide)
50.0Transkription
Die Transkription ist der Prozess der Umwandlung der DNA-Sequenz in eine RNA-Sequenz. Der eigentliche biologische Transkriptionsprozess führt ein umgekehrtes Komplement (TCAG → CUGA) durch, um die mRNA unter Berücksichtigung der DNA als Matrizenstrang zu erhalten. In der Bioinformatik und damit in Biopython arbeiten wir jedoch normalerweise direkt mit dem codierenden Strang und können die mRNA-Sequenz erhalten, indem wir den Buchstaben T in U ändern.
Ein einfaches Beispiel für das Obige ist wie folgt:
>>> from Bio.Seq import Seq
>>> from Bio.Seq import transcribe
>>> from Bio.Alphabet import IUPAC
>>> dna_seq = Seq("ATGCCGATCGTAT",IUPAC.unambiguous_dna) >>> transcribe(dna_seq)
Seq('AUGCCGAUCGUAU', IUPACUnambiguousRNA())
>>>Um die Transkription umzukehren, wird T in U geändert, wie im folgenden Code gezeigt -
>>> rna_seq = transcribe(dna_seq)
>>> rna_seq.back_transcribe()
Seq('ATGCCGATCGTAT', IUPACUnambiguousDNA())Um den DNA-Matrizenstrang zu erhalten, komplementieren Sie die rücktranskribierte RNA wie unten angegeben -
>>> rna_seq.back_transcribe().reverse_complement()
Seq('ATACGATCGGCAT', IUPACUnambiguousDNA())Übersetzung
Die Translation ist ein Prozess der Translation der RNA-Sequenz in die Proteinsequenz. Betrachten Sie eine RNA-Sequenz wie unten gezeigt -
>>> rna_seq = Seq("AUGGCCAUUGUAAU",IUPAC.unambiguous_rna)
>>> rna_seq
Seq('AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG', IUPACUnambiguousRNA())Wenden Sie nun die Funktion translate () auf den obigen Code an -
>>> rna_seq.translate()
Seq('MAIV', IUPACProtein())Die obige RNA-Sequenz ist einfach. Betrachten Sie die RNA-Sequenz AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGA und wenden Sie translate () - an.
>>> rna = Seq('AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGA', IUPAC.unambiguous_rna)
>>> rna.translate()
Seq('MAIVMGR*KGAR', HasStopCodon(IUPACProtein(), '*'))Hier sind die Stoppcodons mit einem Sternchen '*' gekennzeichnet.
In der Methode translate () ist es möglich, beim ersten Stoppcodon anzuhalten. Um dies auszuführen, können Sie_stop = True in translate () wie folgt zuweisen:
>>> rna.translate(to_stop = True)
Seq('MAIVMGR', IUPACProtein())Hier ist das Stoppcodon nicht in der resultierenden Sequenz enthalten, da es keines enthält.
Übersetzungstabelle
Die Seite Genetische Codes des NCBI enthält eine vollständige Liste der von Biopython verwendeten Übersetzungstabellen. Lassen Sie uns ein Beispiel für eine Standardtabelle sehen, um den Code zu visualisieren -
>>> from Bio.Data import CodonTable
>>> table = CodonTable.unambiguous_dna_by_name["Standard"]
>>> print(table)
Table 1 Standard, SGC0
| T | C | A | G |
--+---------+---------+---------+---------+--
T | TTT F | TCT S | TAT Y | TGT C | T
T | TTC F | TCC S | TAC Y | TGC C | C
T | TTA L | TCA S | TAA Stop| TGA Stop| A
T | TTG L(s)| TCG S | TAG Stop| TGG W | G
--+---------+---------+---------+---------+--
C | CTT L | CCT P | CAT H | CGT R | T
C | CTC L | CCC P | CAC H | CGC R | C
C | CTA L | CCA P | CAA Q | CGA R | A
C | CTG L(s)| CCG P | CAG Q | CGG R | G
--+---------+---------+---------+---------+--
A | ATT I | ACT T | AAT N | AGT S | T
A | ATC I | ACC T | AAC N | AGC S | C
A | ATA I | ACA T | AAA K | AGA R | A
A | ATG M(s)| ACG T | AAG K | AGG R | G
--+---------+---------+---------+---------+--
G | GTT V | GCT A | GAT D | GGT G | T
G | GTC V | GCC A | GAC D | GGC G | C
G | GTA V | GCA A | GAA E | GGA G | A
G | GTG V | GCG A | GAG E | GGG G | G
--+---------+---------+---------+---------+--
>>>Biopython verwendet diese Tabelle, um die DNA in Protein zu übersetzen und das Stop-Codon zu finden.
Biopython bietet das Modul Bio.SeqIO zum Lesen und Schreiben von Sequenzen aus und in eine Datei (einen beliebigen Stream). Es unterstützt nahezu alle in der Bioinformatik verfügbaren Dateiformate. Die meisten Programme bieten unterschiedliche Ansätze für unterschiedliche Dateiformate. Biopython verfolgt jedoch bewusst einen einzigen Ansatz, um dem Benutzer die analysierten Sequenzdaten über sein SeqRecord-Objekt zu präsentieren.
Lassen Sie uns im folgenden Abschnitt mehr über SeqRecord erfahren.
SeqRecord
Das Bio.SeqRecord-Modul bietet SeqRecord, um Metainformationen der Sequenz sowie die Sequenzdaten selbst wie unten angegeben zu speichern.
seq - Es ist eine tatsächliche Sequenz.
id - Dies ist die primäre Kennung der angegebenen Sequenz. Der Standardtyp ist Zeichenfolge.
name - Dies ist der Name der Sequenz. Der Standardtyp ist Zeichenfolge.
Beschreibung - Es werden lesbare Informationen über die Sequenz angezeigt.
Anmerkungen - Dies ist ein Wörterbuch mit zusätzlichen Informationen zur Sequenz.
Der SeqRecord kann wie unten angegeben importiert werden
from Bio.SeqRecord import SeqRecordLassen Sie uns in den nächsten Abschnitten die Nuancen des Parsens der Sequenzdatei unter Verwendung einer realen Sequenzdatei verstehen.
Analysieren von Sequenzdateiformaten
In diesem Abschnitt wird erläutert, wie Sie zwei der beliebtesten Sequenzdateiformate analysieren. FASTA und GenBank.
FASTA
FASTAist das grundlegendste Dateiformat zum Speichern von Sequenzdaten. Ursprünglich war FASTA ein Softwarepaket für das Sequenzalignment von DNA und Protein, das während der frühen Evolution der Bioinformatik entwickelt und hauptsächlich zur Suche nach Sequenzähnlichkeit verwendet wurde.
Biopython bietet eine Beispiel-FASTA-Datei, auf die unter zugegriffen werden kann https://github.com/biopython/biopython/blob/master/Doc/examples/ls_orchid.fasta.
Laden Sie diese Datei herunter und speichern Sie sie in Ihrem Biopython-Beispielverzeichnis unter ‘orchid.fasta’.
Das Bio.SeqIO-Modul bietet die parse () -Methode zum Verarbeiten von Sequenzdateien und kann wie folgt importiert werden:
from Bio.SeqIO import parseDie Methode parse () enthält zwei Argumente: das erste ist das Dateihandle und das zweite das Dateiformat.
>>> file = open('path/to/biopython/sample/orchid.fasta')
>>> for record in parse(file, "fasta"):
... print(record.id)
...
gi|2765658|emb|Z78533.1|CIZ78533
gi|2765657|emb|Z78532.1|CCZ78532
..........
..........
gi|2765565|emb|Z78440.1|PPZ78440
gi|2765564|emb|Z78439.1|PBZ78439
>>>Hier gibt die parse () -Methode ein iterierbares Objekt zurück, das bei jeder Iteration SeqRecord zurückgibt. Da es iterierbar ist, bietet es viele ausgefeilte und einfache Methoden und lässt uns einige der Funktionen sehen.
Nächster()
Die Methode next () gibt das nächste im iterierbaren Objekt verfügbare Element zurück, mit dem die erste Sequenz wie unten angegeben abgerufen werden kann.
>>> first_seq_record = next(SeqIO.parse(open('path/to/biopython/sample/orchid.fasta'),'fasta'))
>>> first_seq_record.id 'gi|2765658|emb|Z78533.1|CIZ78533'
>>> first_seq_record.name 'gi|2765658|emb|Z78533.1|CIZ78533'
>>> first_seq_record.seq Seq('CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGATGAGACCGTGG...CGC', SingleLetterAlphabet())
>>> first_seq_record.description 'gi|2765658|emb|Z78533.1|CIZ78533 C.irapeanum 5.8S rRNA gene and ITS1 and ITS2 DNA'
>>> first_seq_record.annotations
{}
>>>Hier ist seq_record.annotations leer, da das FASTA-Format keine Sequenzanmerkungen unterstützt.
Listenverständnis
Wir können das iterierbare Objekt mithilfe des unten angegebenen Listenverständnisses in eine Liste konvertieren
>>> seq_iter = SeqIO.parse(open('path/to/biopython/sample/orchid.fasta'),'fasta')
>>> all_seq = [seq_record for seq_record in seq_iter] >>> len(all_seq)
94
>>>Hier haben wir die len-Methode verwendet, um die Gesamtzahl zu ermitteln. Wir können Sequenz mit maximaler Länge wie folgt erhalten -
>>> seq_iter = SeqIO.parse(open('path/to/biopython/sample/orchid.fasta'),'fasta')
>>> max_seq = max(len(seq_record.seq) for seq_record in seq_iter)
>>> max_seq
789
>>>Wir können die Sequenz auch mit dem folgenden Code filtern -
>>> seq_iter = SeqIO.parse(open('path/to/biopython/sample/orchid.fasta'),'fasta')
>>> seq_under_600 = [seq_record for seq_record in seq_iter if len(seq_record.seq) < 600]
>>> for seq in seq_under_600:
... print(seq.id)
...
gi|2765606|emb|Z78481.1|PIZ78481
gi|2765605|emb|Z78480.1|PGZ78480
gi|2765601|emb|Z78476.1|PGZ78476
gi|2765595|emb|Z78470.1|PPZ78470
gi|2765594|emb|Z78469.1|PHZ78469
gi|2765564|emb|Z78439.1|PBZ78439
>>>Das Schreiben einer Sammlung von SqlRecord-Objekten (analysierte Daten) in eine Datei ist so einfach wie das Aufrufen der SeqIO.write-Methode wie folgt:
file = open("converted.fasta", "w)
SeqIO.write(seq_record, file, "fasta")Diese Methode kann effektiv verwendet werden, um das unten angegebene Format zu konvertieren -
file = open("converted.gbk", "w)
SeqIO.write(seq_record, file, "genbank")GenBank
Es ist ein umfangreicheres Sequenzformat für Gene und enthält Felder für verschiedene Arten von Annotationen. Biopython bietet eine Beispiel-GenBank-Datei, auf die unter zugegriffen werden kannhttps://github.com/biopython/biopython/blob/master/Doc/examples/ls_orchid.fasta.
Laden Sie die Datei herunter und speichern Sie sie in Ihrem Biopython-Beispielverzeichnis unter ‘orchid.gbk’
Da Biopython eine einzige Funktion bietet, analysieren Sie alle Bioinformatik-Formate. Das Parsen des GenBank-Formats ist so einfach wie das Ändern der Formatoption in der Analysemethode.
Der Code dafür wurde unten angegeben -
>>> from Bio import SeqIO
>>> from Bio.SeqIO import parse
>>> seq_record = next(parse(open('path/to/biopython/sample/orchid.gbk'),'genbank'))
>>> seq_record.id
'Z78533.1'
>>> seq_record.name
'Z78533'
>>> seq_record.seq Seq('CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGATGAGACCGTGG...CGC', IUPACAmbiguousDNA())
>>> seq_record.description
'C.irapeanum 5.8S rRNA gene and ITS1 and ITS2 DNA'
>>> seq_record.annotations {
'molecule_type': 'DNA',
'topology': 'linear',
'data_file_division': 'PLN',
'date': '30-NOV-2006',
'accessions': ['Z78533'],
'sequence_version': 1,
'gi': '2765658',
'keywords': ['5.8S ribosomal RNA', '5.8S rRNA gene', 'internal transcribed spacer', 'ITS1', 'ITS2'],
'source': 'Cypripedium irapeanum',
'organism': 'Cypripedium irapeanum',
'taxonomy': [
'Eukaryota',
'Viridiplantae',
'Streptophyta',
'Embryophyta',
'Tracheophyta',
'Spermatophyta',
'Magnoliophyta',
'Liliopsida',
'Asparagales',
'Orchidaceae',
'Cypripedioideae',
'Cypripedium'],
'references': [
Reference(title = 'Phylogenetics of the slipper orchids (Cypripedioideae:
Orchidaceae): nuclear rDNA ITS sequences', ...),
Reference(title = 'Direct Submission', ...)
]
}Sequence alignment ist der Prozess des Anordnens von zwei oder mehr Sequenzen (von DNA-, RNA- oder Proteinsequenzen) in einer bestimmten Reihenfolge, um den Ähnlichkeitsbereich zwischen ihnen zu identifizieren.
Durch die Identifizierung der ähnlichen Region können wir viele Informationen ableiten, z. B. welche Merkmale zwischen den Arten erhalten bleiben, wie nahe die verschiedenen Arten genetisch sind, wie sich die Arten entwickeln usw. Biopython bietet umfassende Unterstützung für die Sequenzausrichtung.
Lassen Sie uns einige der wichtigen Funktionen von Biopython in diesem Kapitel kennenlernen -
Parsing Sequence Alignment
Biopython bietet das Modul Bio.AlignIO zum Lesen und Schreiben von Sequenzalignments. In der Bioinformatik stehen viele Formate zur Verfügung, um die Sequenzausrichtungsdaten ähnlich wie zuvor gelernte Sequenzdaten anzugeben. Bio.AlignIO bietet eine API ähnlich wie Bio.SeqIO, außer dass Bio.SeqIO mit den Sequenzdaten und Bio.AlignIO mit den Sequenzausrichtungsdaten arbeitet.
Bevor Sie mit dem Lernen beginnen, laden Sie eine Beispielsequenz-Alignment-Datei aus dem Internet herunter.
Führen Sie die folgenden Schritte aus, um die Beispieldatei herunterzuladen:
Step 1 - Öffnen Sie Ihren Lieblingsbrowser und gehen Sie zu http://pfam.xfam.org/family/browseWebseite. Es werden alle Pfam-Familien in alphabetischer Reihenfolge angezeigt.
Step 2- Wählen Sie eine Familie mit weniger Samenwert. Es enthält nur minimale Daten und ermöglicht es uns, problemlos mit der Ausrichtung zu arbeiten. Hier haben wir PF18225 ausgewählt / angeklickt und es öffnet sich zuhttp://pfam.xfam.org/family/PF18225 und zeigt vollständige Details dazu, einschließlich Sequenzausrichtungen.
Step 3 - Gehen Sie zum Ausrichtungsabschnitt und laden Sie die Sequenzausrichtungsdatei im Stockholm-Format (PF18225_seed.txt) herunter.
Versuchen wir, die heruntergeladene Sequenzausrichtungsdatei mit Bio.AlignIO wie folgt zu lesen:
Importieren Sie das Bio.AlignIO-Modul
>>> from Bio import AlignIOLeseausrichtung mit Lesemethode. Die Lesemethode wird verwendet, um einzelne Ausrichtungsdaten zu lesen, die in der angegebenen Datei verfügbar sind. Wenn die angegebene Datei viele Ausrichtungen enthält, können wir die Analysemethode verwenden. Die Analysemethode gibt ein iterierbares Ausrichtungsobjekt zurück, das der Analysemethode im Bio.SeqIO-Modul ähnelt.
>>> alignment = AlignIO.read(open("PF18225_seed.txt"), "stockholm")Drucken Sie das Ausrichtungsobjekt.
>>> print(alignment)
SingleLetterAlphabet() alignment with 6 rows and 65 columns
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVA...EGP B7RZ31_9GAMM/59-123
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADIT...KKP A0A0C3NPG9_9PROT/58-119
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMA...KKP A0A143HL37_9GAMM/57-121
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMA...NKP A0A0X3UC67_9GAMM/57-121
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIM...NRK B3PFT7_CELJU/62-126
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVA...NRT K4KEM7_SIMAS/61-125
>>>Wir können auch die Sequenzen (SeqRecord) überprüfen, die im Alignment sowie unten verfügbar sind -
>>> for align in alignment:
... print(align.seq)
...
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVATVANQLRGRKRRAFARHREGP
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADITA---RLDRRREHGEHGVRKKP
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMAPMLIALNYRNRESHAQVDKKP
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMAPLFKVLSFRNREDQGLVNNKP
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIMVLAPRLTAKHPYDKVQDRNRK
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVADLMRKLDLDRPFKKLERKNRT
>>>Mehrere Ausrichtungen
Im Allgemeinen enthalten die meisten Sequenzausrichtungsdateien einzelne Ausrichtungsdaten, und es reicht aus, sie zu verwenden readMethode, um es zu analysieren. Beim Konzept der Ausrichtung mehrerer Sequenzen werden zwei oder mehr Sequenzen verglichen, um die besten Teilsequenzübereinstimmungen zwischen ihnen zu erzielen. Dies führt zu einer Ausrichtung mehrerer Sequenzen in einer einzelnen Datei.
Wenn das Eingabesequenz-Ausrichtungsformat mehr als eine Sequenzausrichtung enthält, müssen wir verwenden parse Methode anstelle von read Methode wie unten angegeben -
>>> from Bio import AlignIO
>>> alignments = AlignIO.parse(open("PF18225_seed.txt"), "stockholm")
>>> print(alignments)
<generator object parse at 0x000001CD1C7E0360>
>>> for alignment in alignments:
... print(alignment)
...
SingleLetterAlphabet() alignment with 6 rows and 65 columns
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVA...EGP B7RZ31_9GAMM/59-123
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADIT...KKP A0A0C3NPG9_9PROT/58-119
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMA...KKP A0A143HL37_9GAMM/57-121
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMA...NKP A0A0X3UC67_9GAMM/57-121
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIM...NRK B3PFT7_CELJU/62-126
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVA...NRT K4KEM7_SIMAS/61-125
>>>Hier gibt die Analysemethode ein iterierbares Ausrichtungsobjekt zurück und kann iteriert werden, um tatsächliche Ausrichtungen zu erhalten.
Paarweise Sequenzausrichtung
Pairwise sequence alignment vergleicht jeweils nur zwei Sequenzen und bietet die bestmögliche Sequenzausrichtung. Pairwise ist leicht zu verstehen und aus der resultierenden Sequenzausrichtung außergewöhnlich abzuleiten.
Biopython bietet ein spezielles Modul, Bio.pairwise2um die Ausrichtungssequenz mit der paarweisen Methode zu identifizieren. Biopython wendet den besten Algorithmus an, um die Ausrichtungssequenz zu finden, und ist mit anderer Software vergleichbar.
Schreiben wir ein Beispiel, um die Sequenzausrichtung zweier einfacher und hypothetischer Sequenzen mithilfe eines paarweisen Moduls zu ermitteln. Dies wird uns helfen, das Konzept der Sequenzausrichtung zu verstehen und wie man es mit Biopython programmiert.
Schritt 1
Importieren Sie das Modul pairwise2 mit dem unten angegebenen Befehl -
>>> from Bio import pairwise2Schritt 2
Erstellen Sie zwei Sequenzen, seq1 und seq2 -
>>> from Bio.Seq import Seq
>>> seq1 = Seq("ACCGGT")
>>> seq2 = Seq("ACGT")Schritt 3
Rufen Sie die Methode pairwise2.align.globalxx zusammen mit seq1 und seq2 auf, um die Ausrichtungen mithilfe der folgenden Codezeile zu finden.
>>> alignments = pairwise2.align.globalxx(seq1, seq2)Hier, globalxxDie Methode führt die eigentliche Arbeit aus und findet die bestmöglichen Ausrichtungen in den angegebenen Sequenzen. Tatsächlich bietet Bio.pairwise2 eine Reihe von Methoden, die der folgenden Konvention folgen, um Ausrichtungen in verschiedenen Szenarien zu finden.
<sequence alignment type>XYHier bezieht sich der Sequenzausrichtungstyp auf den Ausrichtungstyp, der global oder lokal sein kann. Der globale Typ findet die Sequenzausrichtung unter Berücksichtigung der gesamten Sequenz. Der lokale Typ findet die Sequenzausrichtung, indem er auch in die Teilmenge der gegebenen Sequenzen schaut. Dies ist langwierig, bietet jedoch eine bessere Vorstellung von der Ähnlichkeit zwischen den angegebenen Sequenzen.
X bezieht sich auf die übereinstimmende Punktzahl. Die möglichen Werte sind x (genaue Übereinstimmung), m (Bewertung basierend auf identischen Zeichen), d (vom Benutzer bereitgestelltes Wörterbuch mit Zeichen- und Übereinstimmungsbewertung) und schließlich c (benutzerdefinierte Funktion zur Bereitstellung eines benutzerdefinierten Bewertungsalgorithmus).
Y bezieht sich auf die Lückenstrafe. Die möglichen Werte sind x (keine Lückenstrafen), s (gleiche Strafen für beide Sequenzen), d (unterschiedliche Strafen für jede Sequenz) und schließlich c (benutzerdefinierte Funktion zur Bereitstellung benutzerdefinierter Lückenstrafen).
Localds ist also auch eine gültige Methode, bei der die Sequenzausrichtung mithilfe der lokalen Ausrichtungstechnik, des vom Benutzer bereitgestellten Wörterbuchs für Übereinstimmungen und der vom Benutzer bereitgestellten Lückenstrafe für beide Sequenzen ermittelt wird.
>>> test_alignments = pairwise2.align.localds(seq1, seq2, blosum62, -10, -1)Hier bezieht sich blosum62 auf ein Wörterbuch, das im pairwise2-Modul verfügbar ist, um die Übereinstimmungsbewertung bereitzustellen. -10 bezieht sich auf die Lückeöffnungsstrafe und -1 bezieht sich auf die Lückenverlängerungsstrafe.
Schritt 4
Durchlaufen Sie das iterierbare Ausrichtungsobjekt, holen Sie sich jedes einzelne Ausrichtungsobjekt und drucken Sie es aus.
>>> for alignment in alignments:
... print(alignment)
...
('ACCGGT', 'A-C-GT', 4.0, 0, 6)
('ACCGGT', 'AC--GT', 4.0, 0, 6)
('ACCGGT', 'A-CG-T', 4.0, 0, 6)
('ACCGGT', 'AC-G-T', 4.0, 0, 6)Schritt 5
Das Modul Bio.pairwise2 bietet eine Formatierungsmethode, format_alignment, um das Ergebnis besser zu visualisieren.
>>> from Bio.pairwise2 import format_alignment
>>> alignments = pairwise2.align.globalxx(seq1, seq2)
>>> for alignment in alignments:
... print(format_alignment(*alignment))
...
ACCGGT
| | ||
A-C-GT
Score=4
ACCGGT
|| ||
AC--GT
Score=4
ACCGGT
| || |
A-CG-T
Score=4
ACCGGT
|| | |
AC-G-T
Score=4
>>>Biopython bietet auch ein weiteres Modul für die Sequenzausrichtung, Align. Dieses Modul bietet einen anderen Satz von APIs als die einfache Einstellung von Parametern wie Algorithmus, Modus, Match-Score, Lückenstrafen usw. Ein einfacher Blick in das Align-Objekt lautet wie folgt:
>>> from Bio import Align
>>> aligner = Align.PairwiseAligner()
>>> print(aligner)
Pairwise sequence aligner with parameters
match score: 1.000000
mismatch score: 0.000000
target open gap score: 0.000000
target extend gap score: 0.000000
target left open gap score: 0.000000
target left extend gap score: 0.000000
target right open gap score: 0.000000
target right extend gap score: 0.000000
query open gap score: 0.000000
query extend gap score: 0.000000
query left open gap score: 0.000000
query left extend gap score: 0.000000
query right open gap score: 0.000000
query right extend gap score: 0.000000
mode: global
>>>Unterstützung für Sequenzausrichtungswerkzeuge
Biopython bietet über das Bio.Align.Applications-Modul eine Schnittstelle zu vielen Tools zur Sequenzausrichtung. Einige der Tools sind unten aufgeführt -
- ClustalW
- MUSCLE
- EMBOSS Nadel und Wasser
Lassen Sie uns ein einfaches Beispiel in Biopython schreiben, um die Sequenzausrichtung mit dem beliebtesten Ausrichtungswerkzeug ClustalW zu erstellen.
Step 1 - Laden Sie das Clustalw-Programm von herunter http://www.clustal.org/download/current/und installieren Sie es. Aktualisieren Sie außerdem den Systempfad mit dem Installationspfad "clustal".
Step 2 - ClustalwCommanLine aus dem Modul Bio.Align.Applications importieren.
>>> from Bio.Align.Applications import ClustalwCommandlineStep 3 - Legen Sie cmd fest, indem Sie ClustalwCommanLine mit der im Biopython-Paket verfügbaren Eingabedatei opuntia.fasta aufrufen. https://raw.githubusercontent.com/biopython/biopython/master/Doc/examples/opuntia.fasta
>>> cmd = ClustalwCommandline("clustalw2",
infile="/path/to/biopython/sample/opuntia.fasta")
>>> print(cmd)
clustalw2 -infile=fasta/opuntia.fastaStep 4 - Wenn Sie cmd () aufrufen, wird der Befehl clustalw ausgeführt und die resultierende Ausrichtungsdatei opuntia.aln ausgegeben.
>>> stdout, stderr = cmd()Step 5 - Lesen und drucken Sie die Ausrichtungsdatei wie folgt: -
>>> from Bio import AlignIO
>>> align = AlignIO.read("/path/to/biopython/sample/opuntia.aln", "clustal")
>>> print(align)
SingleLetterAlphabet() alignment with 7 rows and 906 columns
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273285|gb|AF191659.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273284|gb|AF191658.1|AF191
TATACATTAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273287|gb|AF191661.1|AF191
TATACATAAAAGAAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273286|gb|AF191660.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273290|gb|AF191664.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273289|gb|AF191663.1|AF191
TATACATTAAAGGAGGGGGATGCGGATAAATGGAAAGGCGAAAG...AGA
gi|6273291|gb|AF191665.1|AF191
>>>BLAST steht für Basic Local Alignment Search Tool. Es findet Ähnlichkeitsbereiche zwischen biologischen Sequenzen. Biopython bietet das Bio.Blast-Modul für den NCBI BLAST-Betrieb. Sie können BLAST entweder in einer lokalen Verbindung oder über eine Internetverbindung ausführen.
Lassen Sie uns diese beiden Zusammenhänge im folgenden Abschnitt kurz verstehen -
Laufen über das Internet
Biopython bietet das Bio.Blast.NCBIWWW-Modul zum Aufrufen der Online-Version von BLAST. Dazu müssen wir das folgende Modul importieren:
>>> from Bio.Blast import NCBIWWWDas NCBIWW-Modul bietet eine qblast-Funktion zum Abfragen der BLAST-Onlineversion. https://blast.ncbi.nlm.nih.gov/Blast.cgi. qblast unterstützt alle von der Online-Version unterstützten Parameter.
Um Hilfe zu diesem Modul zu erhalten, verwenden Sie den folgenden Befehl und verstehen Sie die Funktionen -
>>> help(NCBIWWW.qblast)
Help on function qblast in module Bio.Blast.NCBIWWW:
qblast(
program, database, sequence,
url_base = 'https://blast.ncbi.nlm.nih.gov/Blast.cgi',
auto_format = None,
composition_based_statistics = None,
db_genetic_code = None,
endpoints = None,
entrez_query = '(none)',
expect = 10.0,
filter = None,
gapcosts = None,
genetic_code = None,
hitlist_size = 50,
i_thresh = None,
layout = None,
lcase_mask = None,
matrix_name = None,
nucl_penalty = None,
nucl_reward = None,
other_advanced = None,
perc_ident = None,
phi_pattern = None,
query_file = None,
query_believe_defline = None,
query_from = None,
query_to = None,
searchsp_eff = None,
service = None,
threshold = None,
ungapped_alignment = None,
word_size = None,
alignments = 500,
alignment_view = None,
descriptions = 500,
entrez_links_new_window = None,
expect_low = None,
expect_high = None,
format_entrez_query = None,
format_object = None,
format_type = 'XML',
ncbi_gi = None,
results_file = None,
show_overview = None,
megablast = None,
template_type = None,
template_length = None
)
BLAST search using NCBI's QBLAST server or a cloud service provider.
Supports all parameters of the qblast API for Put and Get.
Please note that BLAST on the cloud supports the NCBI-BLAST Common
URL API (http://ncbi.github.io/blast-cloud/dev/api.html).
To use this feature, please set url_base to 'http://host.my.cloud.service.provider.com/cgi-bin/blast.cgi' and
format_object = 'Alignment'. For more details, please see 8. Biopython – Overview of BLAST
https://blast.ncbi.nlm.nih.gov/Blast.cgi?PAGE_TYPE = BlastDocs&DOC_TYPE = CloudBlast
Some useful parameters:
- program blastn, blastp, blastx, tblastn, or tblastx (lower case)
- database Which database to search against (e.g. "nr").
- sequence The sequence to search.
- ncbi_gi TRUE/FALSE whether to give 'gi' identifier.
- descriptions Number of descriptions to show. Def 500.
- alignments Number of alignments to show. Def 500.
- expect An expect value cutoff. Def 10.0.
- matrix_name Specify an alt. matrix (PAM30, PAM70, BLOSUM80, BLOSUM45).
- filter "none" turns off filtering. Default no filtering
- format_type "HTML", "Text", "ASN.1", or "XML". Def. "XML".
- entrez_query Entrez query to limit Blast search
- hitlist_size Number of hits to return. Default 50
- megablast TRUE/FALSE whether to use MEga BLAST algorithm (blastn only)
- service plain, psi, phi, rpsblast, megablast (lower case)
This function does no checking of the validity of the parameters
and passes the values to the server as is. More help is available at:
https://ncbi.github.io/blast-cloud/dev/api.htmlNormalerweise sind die Argumente der qblast-Funktion grundsätzlich analog zu verschiedenen Parametern, die Sie auf der BLAST-Webseite festlegen können. Dies macht die qblast-Funktion leicht verständlich und verkürzt die Lernkurve, um sie zu verwenden.
Verbinden und Suchen
Um den Prozess des Verbindens und Suchens der BLAST-Online-Version zu verstehen, führen wir eine einfache Sequenzsuche (verfügbar in unserer lokalen Sequenzdatei) gegen den Online-BLAST-Server über Biopython durch.
Step 1 - Erstellen Sie eine Datei mit dem Namen blast_example.fasta im Biopython-Verzeichnis und geben Sie die folgenden Sequenzinformationen als Eingabe ein
Example of a single sequence in FASTA/Pearson format:
>sequence A ggtaagtcctctagtacaaacacccccaatattgtgatataattaaaattatattcatat
tctgttgccagaaaaaacacttttaggctatattagagccatcttctttgaagcgttgtc
>sequence B ggtaagtcctctagtacaaacacccccaatattgtgatataattaaaattatattca
tattctgttgccagaaaaaacacttttaggctatattagagccatcttctttgaagcgttgtcStep 2 - Importieren Sie das NCBIWWW-Modul.
>>> from Bio.Blast import NCBIWWWStep 3 - Öffnen Sie die Sequenzdatei, blast_example.fasta mit Python IO-Modul.
>>> sequence_data = open("blast_example.fasta").read()
>>> sequence_data
'Example of a single sequence in FASTA/Pearson format:\n\n\n> sequence
A\nggtaagtcctctagtacaaacacccccaatattgtgatataattaaaatt
atattcatat\ntctgttgccagaaaaaacacttttaggctatattagagccatcttctttg aagcgttgtc\n\n'Step 4- Rufen Sie nun die qblast-Funktion auf, die Sequenzdaten als Hauptparameter übergibt. Der andere Parameter repräsentiert die Datenbank (nt) und das interne Programm (blastn).
>>> result_handle = NCBIWWW.qblast("blastn", "nt", sequence_data)
>>> result_handle
<_io.StringIO object at 0x000001EC9FAA4558>blast_resultshält das Ergebnis unserer Suche. Es kann zur späteren Verwendung in einer Datei gespeichert und analysiert werden, um die Details zu erhalten. Wir werden im kommenden Abschnitt lernen, wie es geht.
Step 5 - Die gleiche Funktionalität kann auch mit dem Seq-Objekt ausgeführt werden, anstatt die gesamte Fasta-Datei wie unten gezeigt zu verwenden. -
>>> from Bio import SeqIO
>>> seq_record = next(SeqIO.parse(open('blast_example.fasta'),'fasta'))
>>> seq_record.id
'sequence'
>>> seq_record.seq
Seq('ggtaagtcctctagtacaaacacccccaatattgtgatataattaaaattatat...gtc',
SingleLetterAlphabet())Rufen Sie nun die qblast-Funktion auf, die das Seq-Objekt record.seq als Hauptparameter übergibt.
>>> result_handle = NCBIWWW.qblast("blastn", "nt", seq_record.seq)
>>> print(result_handle)
<_io.StringIO object at 0x000001EC9FAA4558>BLAST weist Ihrer Sequenz automatisch eine Kennung zu.
Step 6 - Das result_handle-Objekt enthält das gesamte Ergebnis und kann zur späteren Verwendung in einer Datei gespeichert werden.
>>> with open('results.xml', 'w') as save_file:
>>> blast_results = result_handle.read()
>>> save_file.write(blast_results)Wir werden im späteren Abschnitt sehen, wie die Ergebnisdatei analysiert wird.
Standalone BLAST ausführen
In diesem Abschnitt wird erläutert, wie BLAST im lokalen System ausgeführt wird. Wenn Sie BLAST im lokalen System ausführen, ist es möglicherweise schneller und ermöglicht es Ihnen, eine eigene Datenbank für die Suche nach Sequenzen zu erstellen.
BLAST anschließen
Im Allgemeinen wird die lokale Ausführung von BLAST aufgrund der Größe, des zusätzlichen Aufwands für die Ausführung der Software und der damit verbundenen Kosten nicht empfohlen. Online BLAST ist ausreichend für grundlegende und fortgeschrittene Zwecke. Natürlich müssen Sie es manchmal lokal installieren.
Bedenken Sie, dass Sie häufig online suchen, was viel Zeit und ein hohes Netzwerkvolumen erfordern kann. Wenn Sie proprietäre Sequenzdaten oder IP-bezogene Probleme haben, wird empfohlen, diese lokal zu installieren.
Dazu müssen wir die folgenden Schritte ausführen:
Step 1- Laden Sie die neueste Blast-Binärdatei über den angegebenen Link herunter und installieren Sie sie - ftp://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/LATEST/
Step 2- Laden Sie die neueste und notwendige Datenbank über den folgenden Link herunter und entpacken Sie sie - ftp://ftp.ncbi.nlm.nih.gov/blast/db/
Die BLAST-Software bietet viele Datenbanken auf ihrer Website. Laden Sie die Datei alu.n.gz von der Explosionsdatenbank herunter und entpacken Sie sie in den Ordner alu. Diese Datei ist im FASTA-Format. Um diese Datei in unserer Blast-Anwendung zu verwenden, müssen wir zuerst die Datei vom FASTA-Format in das Blast-Datenbankformat konvertieren. BLAST bietet eine makeblastdb-Anwendung für diese Konvertierung.
Verwenden Sie das folgende Code-Snippet -
cd /path/to/alu
makeblastdb -in alu.n -parse_seqids -dbtype nucl -out alunWenn Sie den obigen Code ausführen, wird die Eingabedatei alu.n analysiert und die BLAST-Datenbank als mehrere Dateien alun.nsq, alun.nsi usw. erstellt. Jetzt können wir diese Datenbank abfragen, um die Sequenz zu finden.
Wir haben den BLAST auf unserem lokalen Server installiert und haben auch eine BLAST-Beispieldatenbank. alun dagegen abfragen.
Step 3- Lassen Sie uns eine Beispielsequenzdatei erstellen, um die Datenbank abzufragen. Erstellen Sie eine Datei search.fsa und fügen Sie die folgenden Daten ein.
>gnl|alu|Z15030_HSAL001056 (Alu-J)
AGGCTGGCACTGTGGCTCATGCTGAAATCCCAGCACGGCGGAGGACGGCGGAAGATTGCT
TGAGCCTAGGAGTTTGCGACCAGCCTGGGTGACATAGGGAGATGCCTGTCTCTACGCAAA
AGAAAAAAAAAATAGCTCTGCTGGTGGTGCATGCCTATAGTCTCAGCTATCAGGAGGCTG
GGACAGGAGGATCACTTGGGCCCGGGAGTTGAGGCTGTGGTGAGCCACGATCACACCACT
GCACTCCAGCCTGGGTGACAGAGCAAGACCCTGTCTCAAAACAAACAAATAA
>gnl|alu|D00596_HSAL003180 (Alu-Sx)
AGCCAGGTGTGGTGGCTCACGCCTGTAATCCCACCGCTTTGGGAGGCTGAGTCAGATCAC
CTGAGGTTAGGAATTTGGGACCAGCCTGGCCAACATGGCGACACCCCAGTCTCTACTAAT
AACACAAAAAATTAGCCAGGTGTGCTGGTGCATGTCTGTAATCCCAGCTACTCAGGAGGC
TGAGGCATGAGAATTGCTCACGAGGCGGAGGTTGTAGTGAGCTGAGATCGTGGCACTGTA
CTCCAGCCTGGCGACAGAGGGAGAACCCATGTCAAAAACAAAAAAAGACACCACCAAAGG
TCAAAGCATA
>gnl|alu|X55502_HSAL000745 (Alu-J)
TGCCTTCCCCATCTGTAATTCTGGCACTTGGGGAGTCCAAGGCAGGATGATCACTTATGC
CCAAGGAATTTGAGTACCAAGCCTGGGCAATATAACAAGGCCCTGTTTCTACAAAAACTT
TAAACAATTAGCCAGGTGTGGTGGTGCGTGCCTGTGTCCAGCTACTCAGGAAGCTGAGGC
AAGAGCTTGAGGCTACAGTGAGCTGTGTTCCACCATGGTGCTCCAGCCTGGGTGACAGGG
CAAGACCCTGTCAAAAGAAAGGAAGAAAGAACGGAAGGAAAGAAGGAAAGAAACAAGGAG
AGDie Sequenzdaten werden aus der Datei alu.n gesammelt. Daher stimmt es mit unserer Datenbank überein.
Step 4 - Die BLAST-Software bietet viele Anwendungen zum Durchsuchen der Datenbank und wir verwenden Blastn. blastn application requires minimum of three arguments, db, query and out. db verweist auf die Datenbank gegen zu suchen; query ist die Reihenfolge zu entsprechen und outist die Datei zum Speichern der Ergebnisse. Führen Sie nun den folgenden Befehl aus, um diese einfache Abfrage auszuführen:
blastn -db alun -query search.fsa -out results.xml -outfmt 5Wenn Sie den obigen Befehl ausführen, wird gesucht und in der Ausgabe ausgegeben results.xml Datei wie unten angegeben (teilweise Daten) -
<?xml version = "1.0"?>
<!DOCTYPE BlastOutput PUBLIC "-//NCBI//NCBI BlastOutput/EN"
"http://www.ncbi.nlm.nih.gov/dtd/NCBI_BlastOutput.dtd">
<BlastOutput>
<BlastOutput_program>blastn</BlastOutput_program>
<BlastOutput_version>BLASTN 2.7.1+</BlastOutput_version>
<BlastOutput_reference>Zheng Zhang, Scott Schwartz, Lukas Wagner, and Webb
Miller (2000), "A greedy algorithm for aligning DNA sequences", J
Comput Biol 2000; 7(1-2):203-14.
</BlastOutput_reference>
<BlastOutput_db>alun</BlastOutput_db>
<BlastOutput_query-ID>Query_1</BlastOutput_query-ID>
<BlastOutput_query-def>gnl|alu|Z15030_HSAL001056 (Alu-J)</BlastOutput_query-def>
<BlastOutput_query-len>292</BlastOutput_query-len>
<BlastOutput_param>
<Parameters>
<Parameters_expect>10</Parameters_expect>
<Parameters_sc-match>1</Parameters_sc-match>
<Parameters_sc-mismatch>-2</Parameters_sc-mismatch>
<Parameters_gap-open>0</Parameters_gap-open>
<Parameters_gap-extend>0</Parameters_gap-extend>
<Parameters_filter>L;m;</Parameters_filter>
</Parameters>
</BlastOutput_param>
<BlastOutput_iterations>
<Iteration>
<Iteration_iter-num>1</Iteration_iter-num><Iteration_query-ID>Query_1</Iteration_query-ID>
<Iteration_query-def>gnl|alu|Z15030_HSAL001056 (Alu-J)</Iteration_query-def>
<Iteration_query-len>292</Iteration_query-len>
<Iteration_hits>
<Hit>
<Hit_num>1</Hit_num>
<Hit_id>gnl|alu|Z15030_HSAL001056</Hit_id>
<Hit_def>(Alu-J)</Hit_def>
<Hit_accession>Z15030_HSAL001056</Hit_accession>
<Hit_len>292</Hit_len>
<Hit_hsps>
<Hsp>
<Hsp_num>1</Hsp_num>
<Hsp_bit-score>540.342</Hsp_bit-score>
<Hsp_score>292</Hsp_score>
<Hsp_evalue>4.55414e-156</Hsp_evalue>
<Hsp_query-from>1</Hsp_query-from>
<Hsp_query-to>292</Hsp_query-to>
<Hsp_hit-from>1</Hsp_hit-from>
<Hsp_hit-to>292</Hsp_hit-to>
<Hsp_query-frame>1</Hsp_query-frame>
<Hsp_hit-frame>1</Hsp_hit-frame>
<Hsp_identity>292</Hsp_identity>
<Hsp_positive>292</Hsp_positive>
<Hsp_gaps>0</Hsp_gaps>
<Hsp_align-len>292</Hsp_align-len>
<Hsp_qseq>
AGGCTGGCACTGTGGCTCATGCTGAAATCCCAGCACGGCGGAGGACGGCGGAAGATTGCTTGAGCCTAGGAGTTTG
CGACCAGCCTGGGTGACATAGGGAGATGCCTGTCTCTACGCAAAAGAAAAAAAAAATAGCTCTGCTGGTGGTGCATG
CCTATAGTCTCAGCTATCAGGAGGCTGGGACAGGAGGATCACTTGGGCCCGGGAGTTGAGGCTGTGGTGAGCC
ACGATCACACCACTGCACTCCAGCCTGGGTGACAGAGCAAGACCCTGTCTCAAAACAAACAAATAA
</Hsp_qseq>
<Hsp_hseq>
AGGCTGGCACTGTGGCTCATGCTGAAATCCCAGCACGGCGGAGGACGGCGGAAGATTGCTTGAGCCTAGGA
GTTTGCGACCAGCCTGGGTGACATAGGGAGATGCCTGTCTCTACGCAAAAGAAAAAAAAAATAGCTCTGCT
GGTGGTGCATGCCTATAGTCTCAGCTATCAGGAGGCTGGGACAGGAGGATCACTTGGGCCCGGGAGTTGAGG
CTGTGGTGAGCCACGATCACACCACTGCACTCCAGCCTGGGTGACAGAGCAAGACCCTGTCTCAAAACAAAC
AAATAA
</Hsp_hseq>
<Hsp_midline>
|||||||||||||||||||||||||||||||||||||||||||||||||||||
|||||||||||||||||||||||||||||||||||||||||||||||||||||
|||||||||||||||||||||||||||||||||||||||||||||||||||||
|||||||||||||||||||||||||||||||||||||||||||||||||||||
|||||||||||||||||||||||||||||||||||||||||||||||||||||
|||||||||||||||||||||||||||
</Hsp_midline>
</Hsp>
</Hit_hsps>
</Hit>
.........................
.........................
.........................
</Iteration_hits>
<Iteration_stat>
<Statistics>
<Statistics_db-num>327</Statistics_db-num>
<Statistics_db-len>80506</Statistics_db-len>
<Statistics_hsp-lenv16</Statistics_hsp-len>
<Statistics_eff-space>21528364</Statistics_eff-space>
<Statistics_kappa>0.46</Statistics_kappa>
<Statistics_lambda>1.28</Statistics_lambda>
<Statistics_entropy>0.85</Statistics_entropy>
</Statistics>
</Iteration_stat>
</Iteration>
</BlastOutput_iterations>
</BlastOutput>Der obige Befehl kann im Python mit dem folgenden Code ausgeführt werden:
>>> from Bio.Blast.Applications import NcbiblastnCommandline
>>> blastn_cline = NcbiblastnCommandline(query = "search.fasta", db = "alun",
outfmt = 5, out = "results.xml")
>>> stdout, stderr = blastn_cline()Hier ist der erste ein Handle für die Explosionsausgabe und der zweite ist die mögliche Fehlerausgabe, die durch den Explosionsbefehl erzeugt wird.
Da wir die Ausgabedatei als Befehlszeilenargument (out = "results.xml") angegeben und das Ausgabeformat als XML (outfmt = 5) festgelegt haben, wird die Ausgabedatei im aktuellen Arbeitsverzeichnis gespeichert.
Analyse des BLAST-Ergebnisses
Im Allgemeinen wird die BLAST-Ausgabe mithilfe des NCBIXML-Moduls als XML-Format analysiert. Dazu müssen wir das folgende Modul importieren:
>>> from Bio.Blast import NCBIXMLJetzt, open the file directly using python open method und use NCBIXML parse method wie unten angegeben -
>>> E_VALUE_THRESH = 1e-20
>>> for record in NCBIXML.parse(open("results.xml")):
>>> if record.alignments:
>>> print("\n")
>>> print("query: %s" % record.query[:100])
>>> for align in record.alignments:
>>> for hsp in align.hsps:
>>> if hsp.expect < E_VALUE_THRESH:
>>> print("match: %s " % align.title[:100])Dies erzeugt eine Ausgabe wie folgt:
query: gnl|alu|Z15030_HSAL001056 (Alu-J)
match: gnl|alu|Z15030_HSAL001056 (Alu-J)
match: gnl|alu|L12964_HSAL003860 (Alu-J)
match: gnl|alu|L13042_HSAL003863 (Alu-FLA?)
match: gnl|alu|M86249_HSAL001462 (Alu-FLA?)
match: gnl|alu|M29484_HSAL002265 (Alu-J)
query: gnl|alu|D00596_HSAL003180 (Alu-Sx)
match: gnl|alu|D00596_HSAL003180 (Alu-Sx)
match: gnl|alu|J03071_HSAL001860 (Alu-J)
match: gnl|alu|X72409_HSAL005025 (Alu-Sx)
query: gnl|alu|X55502_HSAL000745 (Alu-J)
match: gnl|alu|X55502_HSAL000745 (Alu-J)Entrezist ein Online-Suchsystem von NCBI. Es bietet Zugriff auf nahezu alle bekannten molekularbiologischen Datenbanken mit einer integrierten globalen Abfrage, die Boolesche Operatoren und die Feldsuche unterstützt. Es gibt Ergebnisse aus allen Datenbanken mit Informationen wie der Anzahl der Treffer aus jeder Datenbank, Datensätzen mit Links zur Ursprungsdatenbank usw. zurück.
Einige der beliebtesten Datenbanken, auf die über Entrez zugegriffen werden kann, sind nachstehend aufgeführt:
- Pubmed
- Pubmed Central
- Nukleotid (GenBank-Sequenzdatenbank)
- Protein (Sequenzdatenbank)
- Genom (gesamte Genomdatenbank)
- Struktur (dreidimensionale makromolekulare Struktur)
- Taxonomie (Organismen in der GenBank)
- SNP (Single Nucleotide Polymorphism)
- UniGene (genorientierte Cluster von Transkriptsequenzen)
- CDD (Conserved Protein Domain Database)
- 3D-Domänen (Domänen aus Entrez Structure)
Zusätzlich zu den oben genannten Datenbanken bietet Entrez viele weitere Datenbanken für die Feldsuche.
Biopython bietet ein Entrez-spezifisches Modul, Bio.Entrez, für den Zugriff auf die Entrez-Datenbank. In diesem Kapitel erfahren Sie, wie Sie mit Biopython auf Entrez zugreifen können.
Schritte zur Datenbankverbindung
Importieren Sie das folgende Modul, um die Funktionen von Entrez hinzuzufügen:
>>> from Bio import EntrezStellen Sie als Nächstes Ihre E-Mail-Adresse ein, um festzustellen, wer mit dem unten angegebenen Code verbunden ist.
>>> Entrez.email = '<youremail>'Stellen Sie dann den Entrez-Werkzeugparameter ein und standardmäßig ist es Biopython.
>>> Entrez.tool = 'Demoscript'Jetzt, call einfo function to find index term counts, last update, and available links for each database wie unten definiert -
>>> info = Entrez.einfo()Die einfo-Methode gibt ein Objekt zurück, das über die unten gezeigte Lesemethode Zugriff auf die Informationen bietet.
>>> data = info.read()
>>> print(data)
<?xml version = "1.0" encoding = "UTF-8" ?>
<!DOCTYPE eInfoResult PUBLIC "-//NLM//DTD einfo 20130322//EN"
"https://eutils.ncbi.nlm.nih.gov/eutils/dtd/20130322/einfo.dtd">
<eInfoResult>
<DbList>
<DbName>pubmed</DbName>
<DbName>protein</DbName>
<DbName>nuccore</DbName>
<DbName>ipg</DbName>
<DbName>nucleotide</DbName>
<DbName>nucgss</DbName>
<DbName>nucest</DbName>
<DbName>structure</DbName>
<DbName>sparcle</DbName>
<DbName>genome</DbName>
<DbName>annotinfo</DbName>
<DbName>assembly</DbName>
<DbName>bioproject</DbName>
<DbName>biosample</DbName>
<DbName>blastdbinfo</DbName>
<DbName>books</DbName>
<DbName>cdd</DbName>
<DbName>clinvar</DbName>
<DbName>clone</DbName>
<DbName>gap</DbName>
<DbName>gapplus</DbName>
<DbName>grasp</DbName>
<DbName>dbvar</DbName>
<DbName>gene</DbName>
<DbName>gds</DbName>
<DbName>geoprofiles</DbName>
<DbName>homologene</DbName>
<DbName>medgen</DbName>
<DbName>mesh</DbName>
<DbName>ncbisearch</DbName>
<DbName>nlmcatalog</DbName>
<DbName>omim</DbName>
<DbName>orgtrack</DbName>
<DbName>pmc</DbName>
<DbName>popset</DbName>
<DbName>probe</DbName>
<DbName>proteinclusters</DbName>
<DbName>pcassay</DbName>
<DbName>biosystems</DbName>
<DbName>pccompound</DbName>
<DbName>pcsubstance</DbName>
<DbName>pubmedhealth</DbName>
<DbName>seqannot</DbName>
<DbName>snp</DbName>
<DbName>sra</DbName>
<DbName>taxonomy</DbName>
<DbName>biocollections</DbName>
<DbName>unigene</DbName>
<DbName>gencoll</DbName>
<DbName>gtr</DbName>
</DbList>
</eInfoResult>Die Daten sind im XML-Format und verwenden Sie, um die Daten als Python-Objekt abzurufen Entrez.read Methode sobald Entrez.einfo() Methode wird aufgerufen -
>>> info = Entrez.einfo()
>>> record = Entrez.read(info)Hier ist record ein Wörterbuch mit einem Schlüssel, DbList, wie unten gezeigt -
>>> record.keys()
[u'DbList']Durch den Zugriff auf den DbList-Schlüssel wird die unten gezeigte Liste der Datenbanknamen zurückgegeben.
>>> record[u'DbList']
['pubmed', 'protein', 'nuccore', 'ipg', 'nucleotide', 'nucgss',
'nucest', 'structure', 'sparcle', 'genome', 'annotinfo', 'assembly',
'bioproject', 'biosample', 'blastdbinfo', 'books', 'cdd', 'clinvar',
'clone', 'gap', 'gapplus', 'grasp', 'dbvar', 'gene', 'gds', 'geoprofiles',
'homologene', 'medgen', 'mesh', 'ncbisearch', 'nlmcatalog', 'omim',
'orgtrack', 'pmc', 'popset', 'probe', 'proteinclusters', 'pcassay',
'biosystems', 'pccompound', 'pcsubstance', 'pubmedhealth', 'seqannot',
'snp', 'sra', 'taxonomy', 'biocollections', 'unigene', 'gencoll', 'gtr']
>>>Grundsätzlich analysiert das Entrez-Modul das vom Entrez-Suchsystem zurückgegebene XML und stellt es als Python-Wörterbuch und Listen bereit.
Datenbank durchsuchen
Um eine der Entrez-Datenbanken zu durchsuchen, können wir das Modul Bio.Entrez.esearch () verwenden. Es ist unten definiert -
>>> info = Entrez.einfo()
>>> info = Entrez.esearch(db = "pubmed",term = "genome")
>>> record = Entrez.read(info)
>>>print(record)
DictElement({u'Count': '1146113', u'RetMax': '20', u'IdList':
['30347444', '30347404', '30347317', '30347292',
'30347286', '30347249', '30347194', '30347187',
'30347172', '30347088', '30347075', '30346992',
'30346990', '30346982', '30346980', '30346969',
'30346962', '30346954', '30346941', '30346939'],
u'TranslationStack': [DictElement({u'Count':
'927819', u'Field': 'MeSH Terms', u'Term': '"genome"[MeSH Terms]',
u'Explode': 'Y'}, attributes = {})
, DictElement({u'Count': '422712', u'Field':
'All Fields', u'Term': '"genome"[All Fields]', u'Explode': 'N'}, attributes = {}),
'OR', 'GROUP'], u'TranslationSet': [DictElement({u'To': '"genome"[MeSH Terms]
OR "genome"[All Fields]', u'From': 'genome'}, attributes = {})], u'RetStart': '0',
u'QueryTranslation': '"genome"[MeSH Terms] OR "genome"[All Fields]'},
attributes = {})
>>>Wenn Sie eine falsche Datenbank zuweisen, wird diese zurückgegeben
>>> info = Entrez.esearch(db = "blastdbinfo",term = "books")
>>> record = Entrez.read(info)
>>> print(record)
DictElement({u'Count': '0', u'RetMax': '0', u'IdList': [],
u'WarningList': DictElement({u'OutputMessage': ['No items found.'],
u'PhraseIgnored': [], u'QuotedPhraseNotFound': []}, attributes = {}),
u'ErrorList': DictElement({u'FieldNotFound': [], u'PhraseNotFound':
['books']}, attributes = {}), u'TranslationSet': [], u'RetStart': '0',
u'QueryTranslation': '(books[All Fields])'}, attributes = {})Wenn Sie datenbankübergreifend suchen möchten, können Sie verwenden Entrez.egquery. Dies ist ähnlich wieEntrez.esearch Es reicht jedoch aus, das Schlüsselwort anzugeben und den Datenbankparameter zu überspringen.
>>>info = Entrez.egquery(term = "entrez")
>>> record = Entrez.read(info)
>>> for row in record["eGQueryResult"]:
... print(row["DbName"], row["Count"])
...
pubmed 458
pmc 12779 mesh 1
...
...
...
biosample 7
biocollections 0Datensätze abrufen
Enterz bietet eine spezielle Methode, mit der Sie alle Details eines Datensatzes von Entrez suchen und herunterladen können. Betrachten Sie das folgende einfache Beispiel:
>>> handle = Entrez.efetch(
db = "nucleotide", id = "EU490707", rettype = "fasta")Jetzt können wir die Datensätze einfach mit dem SeqIO-Objekt lesen
>>> record = SeqIO.read( handle, "fasta" )
>>> record
SeqRecord(seq = Seq('ATTTTTTACGAACCTGTGGAAATTTTTGGTTATGACAATAAATCTAGTTTAGTA...GAA',
SingleLetterAlphabet()), id = 'EU490707.1', name = 'EU490707.1',
description = 'EU490707.1
Selenipedium aequinoctiale maturase K (matK) gene, partial cds; chloroplast',
dbxrefs = [])Biopython bietet ein Bio.PDB-Modul zur Manipulation von Polypeptidstrukturen. Die PDB (Protein Data Bank) ist die größte online verfügbare Proteinstrukturressource. Es beherbergt viele verschiedene Proteinstrukturen, einschließlich Protein-Protein-, Protein-DNA-, Protein-RNA-Komplexe.
Geben Sie den folgenden Befehl ein, um den PDB zu laden:
from Bio.PDB import *Proteinstruktur-Dateiformate
Das PDB verteilt Proteinstrukturen in drei verschiedenen Formaten -
- Das XML-basierte Dateiformat, das von Biopython nicht unterstützt wird
- Das PDF-Dateiformat, eine speziell formatierte Textdatei
- PDBx / mmCIF-Dateiformat
Von der Proteindatenbank verteilte PDB-Dateien können Formatierungsfehler enthalten, die sie mehrdeutig oder schwer zu analysieren machen. Das Bio.PDB-Modul versucht, diese Fehler automatisch zu behandeln.
Das Bio.PDB-Modul implementiert zwei verschiedene Parser, einen im mmCIF-Format und einen im pdb-Format.
Lassen Sie uns lernen, wie man jedes Format im Detail analysiert -
mmCIF Parser
Laden Sie eine Beispieldatenbank im mmCIF-Format vom pdb-Server mit dem folgenden Befehl herunter:
>>> pdbl = PDBList()
>>> pdbl.retrieve_pdb_file('2FAT', pdir = '.', file_format = 'mmCif')Dadurch wird die angegebene Datei (2fat.cif) vom Server heruntergeladen und im aktuellen Arbeitsverzeichnis gespeichert.
Hier bietet PDBList Optionen zum Auflisten und Herunterladen von Dateien vom Online-PDB-FTP-Server. Die Methode retrieve_pdb_file benötigt den Namen der Datei, die ohne Erweiterung heruntergeladen werden soll. retrieve_pdb_file hat auch die Option, das Download-Verzeichnis, das pdir und das Format der Datei, file_format, anzugeben. Die möglichen Werte des Dateiformats sind wie folgt:
- "MmCif" (Standard, PDBx / mmCif-Datei)
- "Pdb" (Format PDB)
- "XML" (PMDML / XML-Format)
- "Mmtf" (stark komprimiert)
- "Bundle" (PDB-formatiertes Archiv für große Strukturen)
Verwenden Sie zum Laden einer CIF-Datei Bio.MMCIF.MMCIFParser wie unten angegeben -
>>> parser = MMCIFParser(QUIET = True)
>>> data = parser.get_structure("2FAT", "2FAT.cif")Hier unterdrückt QUIET die Warnung beim Parsen der Datei. get_structure will parse the file and return the structure with id as 2FAT (erstes Argument).
Nach dem Ausführen des obigen Befehls wird die Datei analysiert und eine mögliche Warnung gedruckt, falls verfügbar.
Überprüfen Sie nun die Struktur mit dem folgenden Befehl:
>>> data
<Structure id = 2FAT>
To get the type, use type method as specified below,
>>> print(type(data))
<class 'Bio.PDB.Structure.Structure'>Wir haben die Datei erfolgreich analysiert und die Struktur des Proteins ermittelt. Wir werden die Details der Proteinstruktur und wie man sie erhält, im späteren Kapitel lernen.
PDB-Parser
Laden Sie eine Beispieldatenbank im PDB-Format mit dem folgenden Befehl vom pdb-Server herunter:
>>> pdbl = PDBList()
>>> pdbl.retrieve_pdb_file('2FAT', pdir = '.', file_format = 'pdb')Dadurch wird die angegebene Datei (pdb2fat.ent) vom Server heruntergeladen und im aktuellen Arbeitsverzeichnis gespeichert.
Verwenden Sie zum Laden einer PDF-Datei Bio.PDB.PDBParser wie unten angegeben -
>>> parser = PDBParser(PERMISSIVE = True, QUIET = True)
>>> data = parser.get_structure("2fat","pdb2fat.ent")Hier ähnelt get_structure MMCIFParser. Die Option PERMISSIVE versucht, die Proteindaten so flexibel wie möglich zu analysieren.
Überprüfen Sie nun die Struktur und ihren Typ mit dem unten angegebenen Code-Snippet -
>>> data
<Structure id = 2fat>
>>> print(type(data))
<class 'Bio.PDB.Structure.Structure'>Nun, die Header-Struktur speichert die Wörterbuchinformationen. Geben Sie dazu den folgenden Befehl ein:
>>> print(data.header.keys()) dict_keys([
'name', 'head', 'deposition_date', 'release_date', 'structure_method', 'resolution',
'structure_reference', 'journal_reference', 'author', 'compound', 'source',
'keywords', 'journal'])
>>>Verwenden Sie den folgenden Code, um den Namen zu erhalten:
>>> print(data.header["name"])
an anti-urokinase plasminogen activator receptor (upar) antibody: crystal
structure and binding epitope
>>>Sie können das Datum und die Auflösung auch mit dem folgenden Code überprüfen -
>>> print(data.header["release_date"]) 2006-11-14
>>> print(data.header["resolution"]) 1.77PDB-Struktur
Die PDB-Struktur besteht aus einem einzelnen Modell, das zwei Ketten enthält.
- Kette L, die die Anzahl der Reste enthält
- Kette H, die die Anzahl der Reste enthält
Jeder Rest besteht aus mehreren Atomen, von denen jedes eine 3D-Position aufweist, die durch (x, y, z) -Koordinaten dargestellt wird.
Lassen Sie uns im folgenden Abschnitt lernen, wie man die Struktur des Atoms im Detail erhält -
Modell
Die Structure.get_models () -Methode gibt einen Iterator über die Modelle zurück. Es ist unten definiert -
>>> model = data.get_models()
>>> model
<generator object get_models at 0x103fa1c80>
>>> models = list(model)
>>> models [<Model id = 0>]
>>> type(models[0])
<class 'Bio.PDB.Model.Model'>Hier beschreibt ein Modell genau eine 3D-Konformation. Es enthält eine oder mehrere Ketten.
Kette
Die Model.get_chain () -Methode gibt einen Iterator über die Ketten zurück. Es ist unten definiert -
>>> chains = list(models[0].get_chains())
>>> chains
[<Chain id = L>, <Chain id = H>]
>>> type(chains[0])
<class 'Bio.PDB.Chain.Chain'>Hier beschreibt Chain eine geeignete Polypeptidstruktur, dh eine aufeinanderfolgende Sequenz gebundener Reste.
Rückstand
Die Chain.get_residues () -Methode gibt einen Iterator über die Reste zurück. Es ist unten definiert -
>>> residue = list(chains[0].get_residues())
>>> len(residue)
293
>>> residue1 = list(chains[1].get_residues())
>>> len(residue1)
311Nun, Rest enthält die Atome, die zu einer Aminosäure gehören.
Atome
Das Residue.get_atom () gibt einen Iterator über die Atome zurück, wie unten definiert -
>>> atoms = list(residue[0].get_atoms())
>>> atoms
[<Atom N>, <Atom CA>, <Atom C>, <Atom Ov, <Atom CB>, <Atom CG>, <Atom OD1>, <Atom OD2>]Ein Atom enthält die 3D-Koordinate eines Atoms und wird als Vektor bezeichnet. Es ist unten definiert
>>> atoms[0].get_vector()
<Vector 18.49, 73.26, 44.16>Es repräsentiert x-, y- und z-Koordinatenwerte.
Ein Sequenzmotiv ist ein Nukleotid- oder Aminosäuresequenzmuster. Sequenzmotive werden durch dreidimensionale Anordnung von Aminosäuren gebildet, die möglicherweise nicht benachbart sind. Biopython bietet ein separates Modul, Bio.motifs, um auf die unten angegebenen Funktionen des Sequenzmotivs zuzugreifen.
from Bio import motifsEinfaches DNA-Motiv erstellen
Lassen Sie uns eine einfache DNA-Motivsequenz mit dem folgenden Befehl erstellen -
>>> from Bio import motifs
>>> from Bio.Seq import Seq
>>> DNA_motif = [ Seq("AGCT"),
... Seq("TCGA"),
... Seq("AACT"),
... ]
>>> seq = motifs.create(DNA_motif)
>>> print(seq) AGCT TCGA AACTVerwenden Sie den folgenden Befehl, um die Sequenzwerte zu zählen -
>>> print(seq.counts)
0 1 2 3
A: 2.00 1.00 0.00 1.00
C: 0.00 1.00 2.00 0.00
G: 0.00 1.00 1.00 0.00
T: 1.00 0.00 0.00 2.00Verwenden Sie den folgenden Code, um 'A' in der Sequenz zu zählen -
>>> seq.counts["A", :]
(2, 1, 0, 1)Wenn Sie auf die Zählspalten zugreifen möchten, verwenden Sie den folgenden Befehl:
>>> seq.counts[:, 3]
{'A': 1, 'C': 0, 'T': 2, 'G': 0}Erstellen eines Sequenzlogos
Wir werden nun diskutieren, wie ein Sequenzlogo erstellt wird.
Betrachten Sie die folgende Reihenfolge -
AGCTTACG
ATCGTACC
TTCCGAAT
GGTACGTA
AAGCTTGGÜber den folgenden Link können Sie Ihr eigenes Logo erstellen: http://weblogo.berkeley.edu/
Fügen Sie die obige Sequenz hinzu, erstellen Sie ein neues Logo und speichern Sie das Bild mit dem Namen seq.png in Ihrem Biopython-Ordner.
seq.png
Führen Sie nach dem Erstellen des Images den folgenden Befehl aus:
>>> seq.weblogo("seq.png")Dieses DNA-Sequenzmotiv wird als Sequenzlogo für das LexA-Bindungsmotiv dargestellt.
JASPAR-Datenbank
JASPAR ist eine der beliebtesten Datenbanken. Es bietet Funktionen aller Motivformate zum Lesen, Schreiben und Scannen von Sequenzen. Es speichert Metainformationen für jedes Motiv.The module Bio.motifs contains a specialized class jaspar.Motif to represent meta-information attributes.
Es hat die folgenden bemerkenswerten Attributtypen -
- matrix_id - Eindeutige JASPAR-Motiv-ID
- name - Der Name des Motivs
- tf_family - Die Motivfamilie, zB 'Helix-Loop-Helix'
- Datentyp - Der Datentyp, der im Motiv verwendet wird.
Lassen Sie uns ein JASPAR-Site-Format erstellen, das in sample.sites im Biopython-Ordner benannt ist. Es ist unten definiert -
sample.sites
>MA0001 ARNT 1
AACGTGatgtccta
>MA0001 ARNT 2
CAGGTGggatgtac
>MA0001 ARNT 3
TACGTAgctcatgc
>MA0001 ARNT 4
AACGTGacagcgct
>MA0001 ARNT 5
CACGTGcacgtcgt
>MA0001 ARNT 6
cggcctCGCGTGcIn der obigen Datei haben wir Motivinstanzen erstellt. Lassen Sie uns nun aus den obigen Instanzen ein Motivobjekt erstellen -
>>> from Bio import motifs
>>> with open("sample.sites") as handle:
... data = motifs.read(handle,"sites")
...
>>> print(data)
TF name None
Matrix ID None
Matrix:
0 1 2 3 4 5
A: 2.00 5.00 0.00 0.00 0.00 1.00
C: 3.00 0.00 5.00 0.00 0.00 0.00
G: 0.00 1.00 1.00 6.00 0.00 5.00
T: 1.00 0.00 0.00 0.00 6.00 0.00Hier lesen Daten alle Motivinstanzen aus der Datei sample.sites.
Verwenden Sie den folgenden Befehl, um alle Instanzen aus Daten zu drucken:
>>> for instance in data.instances:
... print(instance)
...
AACGTG
CAGGTG
TACGTA
AACGTG
CACGTG
CGCGTGVerwenden Sie den folgenden Befehl, um alle Werte zu zählen -
>>> print(data.counts)
0 1 2 3 4 5
A: 2.00 5.00 0.00 0.00 0.00 1.00
C: 3.00 0.00 5.00 0.00 0.00 0.00
G: 0.00 1.00 1.00 6.00 0.00 5.00
T: 1.00 0.00 0.00 0.00 6.00 0.00
>>>BioSQList ein generisches Datenbankschema, das hauptsächlich zum Speichern von Sequenzen und den zugehörigen Daten für alle RDBMS-Engines entwickelt wurde. Es ist so konzipiert, dass es die Daten aus allen gängigen Bioinformatik-Datenbanken wie GenBank, Swissport usw. enthält. Es kann auch zum Speichern von internen Daten verwendet werden.
BioSQL bietet derzeit ein spezifisches Schema für die folgenden Datenbanken -
- MySQL (biosqldb-mysql.sql)
- PostgreSQL (biosqldb-pg.sql)
- Oracle (biosqldb-ora / *. Sql)
- SQLite (biosqldb-sqlite.sql)
Es bietet auch minimale Unterstützung für Java-basierte HSQLDB- und Derby-Datenbanken.
BioPython bietet sehr einfache, einfache und erweiterte ORM-Funktionen für die Arbeit mit BioSQL-basierten Datenbanken. BioPython provides a module, BioSQL um die folgende Funktionalität zu tun -
- Erstellen / Entfernen einer BioSQL-Datenbank
- Stellen Sie eine Verbindung zu einer BioSQL-Datenbank her
- Analysieren Sie eine Sequenzdatenbank wie GenBank, Swisport, BLAST-Ergebnis, Entrez-Ergebnis usw. und laden Sie sie direkt in die BioSQL-Datenbank
- Rufen Sie die Sequenzdaten aus der BioSQL-Datenbank ab
- Rufen Sie Taxonomiedaten von NCBI BLAST ab und speichern Sie sie in der BioSQL-Datenbank
- Führen Sie eine SQL-Abfrage für die BioSQL-Datenbank aus
Übersicht über das BioSQL-Datenbankschema
Bevor wir uns eingehend mit BioSQL befassen, sollten wir uns mit den Grundlagen des BioSQL-Schemas vertraut machen. Das BioSQL-Schema bietet mehr als 25 Tabellen für Sequenzdaten, Sequenzmerkmale, Sequenzkategorie / Ontologie und Taxonomieinformationen. Einige der wichtigen Tabellen lauten wie folgt:
- biodatabase
- bioentry
- biosequence
- seqfeature
- taxon
- taxon_name
- antology
- term
- dxref
Erstellen einer BioSQL-Datenbank
In diesem Abschnitt erstellen wir eine BioSQL-Beispieldatenbank, biosql, unter Verwendung des vom BioSQL-Team bereitgestellten Schemas. Wir werden mit der SQLite-Datenbank arbeiten, da der Einstieg sehr einfach ist und keine komplexe Einrichtung aufweist.
Hier erstellen wir eine SQLite-basierte BioSQL-Datenbank mit den folgenden Schritten.
Step 1 - Laden Sie die SQLite-Datenbank-Engine herunter und installieren Sie sie.
Step 2 - Laden Sie das BioSQL-Projekt von der GitHub-URL herunter. https://github.com/biosql/biosql
Step 3 - Öffnen Sie eine Konsole, erstellen Sie mit mkdir ein Verzeichnis und geben Sie es ein.
cd /path/to/your/biopython/sample
mkdir sqlite-biosql
cd sqlite-biosqlStep 4 - Führen Sie den folgenden Befehl aus, um eine neue SQLite-Datenbank zu erstellen.
> sqlite3.exe mybiosql.db
SQLite version 3.25.2 2018-09-25 19:08:10
Enter ".help" for usage hints.
sqlite>Step 5 - Kopieren Sie die Datei biosqldb-sqlite.sql aus dem BioSQL-Projekt (/ sql / biosqldb-sqlite.sql`) und speichern Sie sie im aktuellen Verzeichnis.
Step 6 - Führen Sie den folgenden Befehl aus, um alle Tabellen zu erstellen.
sqlite> .read biosqldb-sqlite.sqlJetzt werden alle Tabellen in unserer neuen Datenbank erstellt.
Step 7 - Führen Sie den folgenden Befehl aus, um alle neuen Tabellen in unserer Datenbank anzuzeigen.
sqlite> .headers on
sqlite> .mode column
sqlite> .separator ROW "\n"
sqlite> SELECT name FROM sqlite_master WHERE type = 'table';
biodatabase
taxon
taxon_name
ontology
term
term_synonym
term_dbxref
term_relationship
term_relationship_term
term_path
bioentry
bioentry_relationship
bioentry_path
biosequence
dbxref
dbxref_qualifier_value
bioentry_dbxref
reference
bioentry_reference
comment
bioentry_qualifier_value
seqfeature
seqfeature_relationship
seqfeature_path
seqfeature_qualifier_value
seqfeature_dbxref
location
location_qualifier_value
sqlite>Die ersten drei Befehle sind Konfigurationsbefehle zum Konfigurieren von SQLite, um das Ergebnis formatiert anzuzeigen.
Step 8 - Kopieren Sie die vom BioPython-Team bereitgestellte GenBank-Beispieldatei ls_orchid.gbk https://raw.githubusercontent.com/biopython/biopython/master/Doc/examples/ls_orchid.gbk in das aktuelle Verzeichnis und speichern Sie es als orchid.gbk.
Step 9 - Erstellen Sie ein Python-Skript, load_orchid.py, mit dem folgenden Code und führen Sie es aus.
from Bio import SeqIO
from BioSQL import BioSeqDatabase
import os
server = BioSeqDatabase.open_database(driver = 'sqlite3', db = "orchid.db")
db = server.new_database("orchid")
count = db.load(SeqIO.parse("orchid.gbk", "gb"), True) server.commit()
server.close()Der obige Code analysiert den Datensatz in der Datei, konvertiert ihn in Python-Objekte und fügt ihn in die BioSQL-Datenbank ein. Wir werden den Code im späteren Abschnitt analysieren.
Schließlich haben wir eine neue BioSQL-Datenbank erstellt und einige Beispieldaten in diese geladen. Wir werden die wichtigen Tabellen im nächsten Kapitel diskutieren.
Einfaches ER-Diagramm
biodatabase Die Tabelle befindet sich oben in der Hierarchie und dient hauptsächlich dazu, einen Satz von Sequenzdaten in einer einzelnen Gruppe / virtuellen Datenbank zu organisieren. Every entry in the biodatabase refers to a separate database and it does not mingle with another database. Alle zugehörigen Tabellen in der BioSQL-Datenbank enthalten Verweise auf den Eintrag in die Biodatabase.
bioentryDie Tabelle enthält alle Details zu einer Sequenz mit Ausnahme der Sequenzdaten. Sequenzdaten eines bestimmtenbioentry wird gespeichert in biosequence Tabelle.
taxon und taxon_name sind Taxonomiedetails und jeder Eintrag verweist auf diese Tabelle, um seine Taxoninformationen anzugeben.
Nachdem wir das Schema verstanden haben, wollen wir uns im nächsten Abschnitt einige Fragen ansehen.
BioSQL-Abfragen
Lassen Sie uns einige SQL-Abfragen untersuchen, um besser zu verstehen, wie die Daten organisiert sind und die Tabellen miteinander in Beziehung stehen. Bevor Sie fortfahren, öffnen wir die Datenbank mit dem folgenden Befehl und legen einige Formatierungsbefehle fest.
> sqlite3 orchid.db
SQLite version 3.25.2 2018-09-25 19:08:10
Enter ".help" for usage hints.
sqlite> .header on
sqlite> .mode columns.header and .mode are formatting options to better visualize the data. Sie können die Abfrage auch mit einem beliebigen SQLite-Editor ausführen.
Listen Sie die im System verfügbare virtuelle Sequenzdatenbank wie folgt auf:
select
*
from
biodatabase;
*** Result ***
sqlite> .width 15 15 15 15
sqlite> select * from biodatabase;
biodatabase_id name authority description
--------------- --------------- --------------- ---------------
1 orchid
sqlite>Hier haben wir nur eine Datenbank, orchid.
Listen Sie die in der Datenbank verfügbaren Einträge (Top 3) auf orchid mit dem unten angegebenen Code
select
be.*,
bd.name
from
bioentry be
inner join
biodatabase bd
on bd.biodatabase_id = be.biodatabase_id
where
bd.name = 'orchid' Limit 1,
3;
*** Result ***
sqlite> .width 15 15 10 10 10 10 10 50 10 10
sqlite> select be.*, bd.name from bioentry be inner join biodatabase bd on
bd.biodatabase_id = be.biodatabase_id where bd.name = 'orchid' Limit 1,3;
bioentry_id biodatabase_id taxon_id name accession identifier division description version name
--------------- --------------- ---------- ---------- ---------- ---------- ----------
---------- ---------- ----------- ---------- --------- ---------- ----------
2 1 19 Z78532 Z78532 2765657 PLN
C.californicum 5.8S rRNA gene and ITS1 and ITS2 DN 1
orchid
3 1 20 Z78531 Z78531 2765656 PLN
C.fasciculatum 5.8S rRNA gene and ITS1 and ITS2 DN 1
orchid
4 1 21 Z78530 Z78530 2765655 PLN
C.margaritaceum 5.8S rRNA gene and ITS1 and ITS2 D 1
orchid
sqlite>Listen Sie die mit einem Eintrag verbundenen Sequenzdetails (Zugang - Z78530, Name - C. fasciculatum 5.8S rRNA-Gen und ITS1- und ITS2-DNA) mit dem angegebenen Code auf -
select
substr(cast(bs.seq as varchar), 0, 10) || '...' as seq,
bs.length,
be.accession,
be.description,
bd.name
from
biosequence bs
inner join
bioentry be
on be.bioentry_id = bs.bioentry_id
inner join
biodatabase bd
on bd.biodatabase_id = be.biodatabase_id
where
bd.name = 'orchid'
and be.accession = 'Z78532';
*** Result ***
sqlite> .width 15 5 10 50 10
sqlite> select substr(cast(bs.seq as varchar), 0, 10) || '...' as seq,
bs.length, be.accession, be.description, bd.name from biosequence bs inner
join bioentry be on be.bioentry_id = bs.bioentry_id inner join biodatabase bd
on bd.biodatabase_id = be.biodatabase_id where bd.name = 'orchid' and
be.accession = 'Z78532';
seq length accession description name
------------ ---------- ---------- ------------ ------------ ---------- ---------- -----------------
CGTAACAAG... 753 Z78532 C.californicum 5.8S rRNA gene and ITS1 and ITS2 DNA orchid
sqlite>Holen Sie sich die vollständige Sequenz, die einem Eintrag zugeordnet ist (Zugang - Z78530, Name - C. fasciculatum 5.8S rRNA-Gen und ITS1- und ITS2-DNA), unter Verwendung des folgenden Codes:
select
bs.seq
from
biosequence bs
inner join
bioentry be
on be.bioentry_id = bs.bioentry_id
inner join
biodatabase bd
on bd.biodatabase_id = be.biodatabase_id
where
bd.name = 'orchid'
and be.accession = 'Z78532';
*** Result ***
sqlite> .width 1000
sqlite> select bs.seq from biosequence bs inner join bioentry be on
be.bioentry_id = bs.bioentry_id inner join biodatabase bd on bd.biodatabase_id =
be.biodatabase_id where bd.name = 'orchid' and be.accession = 'Z78532';
seq
----------------------------------------------------------------------------------------
----------------------------
CGTAACAAGGTTTCCGTAGGTGAACCTGCGGAAGGATCATTGTTGAGACAACAGAATATATGATCGAGTGAATCT
GGAGGACCTGTGGTAACTCAGCTCGTCGTGGCACTGCTTTTGTCGTGACCCTGCTTTGTTGTTGGGCCTCC
TCAAGAGCTTTCATGGCAGGTTTGAACTTTAGTACGGTGCAGTTTGCGCCAAGTCATATAAAGCATCACTGATGAATGACATTATTGT
CAGAAAAAATCAGAGGGGCAGTATGCTACTGAGCATGCCAGTGAATTTTTATGACTCTCGCAACGGATATCTTGGCTC
TAACATCGATGAAGAACGCAG
sqlite>Liste Taxon mit Bio-Datenbank, Orchidee verbunden
select distinct
tn.name
from
biodatabase d
inner join
bioentry e
on e.biodatabase_id = d.biodatabase_id
inner join
taxon t
on t.taxon_id = e.taxon_id
inner join
taxon_name tn
on tn.taxon_id = t.taxon_id
where
d.name = 'orchid' limit 10;
*** Result ***
sqlite> select distinct tn.name from biodatabase d inner join bioentry e on
e.biodatabase_id = d.biodatabase_id inner join taxon t on t.taxon_id =
e.taxon_id inner join taxon_name tn on tn.taxon_id = t.taxon_id where d.name =
'orchid' limit 10;
name
------------------------------
Cypripedium irapeanum
Cypripedium californicum
Cypripedium fasciculatum
Cypripedium margaritaceum
Cypripedium lichiangense
Cypripedium yatabeanum
Cypripedium guttatum
Cypripedium acaule
pink lady's slipper
Cypripedium formosanum
sqlite>Laden Sie Daten in die BioSQL-Datenbank
In diesem Kapitel erfahren Sie, wie Sie Sequenzdaten in die BioSQL-Datenbank laden. Wir haben bereits den Code zum Laden von Daten in die Datenbank im vorherigen Abschnitt und der Code lautet wie folgt:
from Bio import SeqIO
from BioSQL import BioSeqDatabase
import os
server = BioSeqDatabase.open_database(driver = 'sqlite3', db = "orchid.db")
DBSCHEMA = "biosqldb-sqlite.sql"
SQL_FILE = os.path.join(os.getcwd(), DBSCHEMA)
server.load_database_sql(SQL_FILE)
server.commit()
db = server.new_database("orchid")
count = db.load(SeqIO.parse("orchid.gbk", "gb"), True) server.commit()
server.close()Wir werden uns jede Zeile des Codes und seinen Zweck genauer ansehen -
Line 1 - Lädt das SeqIO-Modul.
Line 2- Lädt das BioSeqDatabase-Modul. Dieses Modul bietet alle Funktionen für die Interaktion mit der BioSQL-Datenbank.
Line 3 - Lädt das OS-Modul.
Line 5- open_database öffnet die angegebene Datenbank (db) mit dem konfigurierten Treiber (Treiber) und gibt ein Handle an die BioSQL-Datenbank (Server) zurück. Biopython unterstützt SQLite-, MySQL-, Postgresql- und Oracle-Datenbanken.
Line 6-10- Die Methode load_database_sql lädt die SQL aus der externen Datei und führt sie aus. Die Commit-Methode schreibt die Transaktion fest. Wir können diesen Schritt überspringen, da wir die Datenbank bereits mit Schema erstellt haben.
Line 12 - new_database-Methoden erstellen eine neue virtuelle Datenbank, Orchidee und geben eine Handle-Datenbank zurück, um den Befehl für die Orchideendatenbank auszuführen.
Line 13- Die Methode load lädt die Sequenzeinträge (iterable SeqRecord) in die Orchideendatenbank. SqlIO.parse analysiert die GenBank-Datenbank und gibt alle darin enthaltenen Sequenzen als iterierbaren SeqRecord zurück. Der zweite Parameter (True) der Lademethode weist sie an, die Taxonomiedetails der Sequenzdaten von der NCBI-Explosionswebsite abzurufen, sofern diese nicht bereits im System verfügbar sind.
Line 14 - Commit schreibt die Transaktion fest.
Line 15 - close schließt die Datenbankverbindung und zerstört das Serverhandle.
Holen Sie sich die Sequenzdaten
Lassen Sie uns eine Sequenz mit der Kennung 2765658 aus der Orchideendatenbank wie folgt abrufen -
from BioSQL import BioSeqDatabase
server = BioSeqDatabase.open_database(driver = 'sqlite3', db = "orchid.db")
db = server["orchid"]
seq_record = db.lookup(gi = 2765658)
print(seq_record.id, seq_record.description[:50] + "...")
print("Sequence length %i," % len(seq_record.seq))Hier gibt Server ["Orchidee"] das Handle zurück, um Daten aus der virtuellen Datenbankorchid abzurufen. lookup Methode bietet eine Option zur Auswahl von Sequenzen basierend auf Kriterien und wir haben die Sequenz mit der Kennung 2765658 ausgewählt. lookupGibt die Sequenzinformationen als SeqRecordobject zurück. Da wir bereits wissen, wie man mit SeqRecord arbeitet, ist es einfach, Daten daraus zu erhalten.
Entfernen Sie eine Datenbank
Das Entfernen einer Datenbank ist so einfach wie das Aufrufen der Methode remove_database mit dem richtigen Datenbanknamen und das anschließende Festschreiben wie unten angegeben.
from BioSQL import BioSeqDatabase
server = BioSeqDatabase.open_database(driver = 'sqlite3', db = "orchid.db")
server.remove_database("orchids")
server.commit()Die Populationsgenetik spielt eine wichtige Rolle in der Evolutionstheorie. Es analysiert den genetischen Unterschied zwischen Arten sowie zwei oder mehr Individuen innerhalb derselben Art.
Biopython bietet das Bio.PopGen-Modul für die Populationsgenetik und unterstützt hauptsächlich GenePop, ein beliebtes Genetikpaket, das von Michel Raymond und Francois Rousset entwickelt wurde.
Ein einfacher Parser
Lassen Sie uns eine einfache Anwendung schreiben, um das GenePop-Format zu analysieren und das Konzept zu verstehen.
Laden Sie die vom Biopython-Team bereitgestellte genePop-Datei unter dem unten angegebenen Link herunter -https://raw.githubusercontent.com/biopython/biopython/master/Tests/PopGen/c3line.gen
Laden Sie das GenePop-Modul mit dem folgenden Code-Snippet -
from Bio.PopGen import GenePopAnalysieren Sie die Datei mit der GenePop.read-Methode wie folgt:
record = GenePop.read(open("c3line.gen"))Zeigen Sie die Loci und Bevölkerungsinformationen wie unten angegeben an -
>>> record.loci_list
['136255903', '136257048', '136257636']
>>> record.pop_list
['4', 'b3', '5']
>>> record.populations
[[('1', [(3, 3), (4, 4), (2, 2)]), ('2', [(3, 3), (3, 4), (2, 2)]),
('3', [(3, 3), (4, 4), (2, 2)]), ('4', [(3, 3), (4, 3), (None, None)])],
[('b1', [(None, None), (4, 4), (2, 2)]), ('b2', [(None, None), (4, 4), (2, 2)]),
('b3', [(None, None), (4, 4), (2, 2)])],
[('1', [(3, 3), (4, 4), (2, 2)]), ('2', [(3, 3), (1, 4), (2, 2)]),
('3', [(3, 2), (1, 1), (2, 2)]), ('4',
[(None, None), (4, 4), (2, 2)]), ('5', [(3, 3), (4, 4), (2, 2)])]]
>>>Hier sind drei Loci in der Datei und drei Bevölkerungsgruppen verfügbar: Die erste Population hat 4 Datensätze, die zweite Population hat 3 Datensätze und die dritte Population hat 5 Datensätze. record.populations zeigt alle Bevölkerungsgruppen mit Alleldaten für jeden Ort.
Bearbeiten Sie die GenePop-Datei
Biopython bietet Optionen zum Entfernen von Orts- und Populationsdaten.
Remove a population set by position,
>>> record.remove_population(0)
>>> record.populations
[[('b1', [(None, None), (4, 4), (2, 2)]),
('b2', [(None, None), (4, 4), (2, 2)]),
('b3', [(None, None), (4, 4), (2, 2)])],
[('1', [(3, 3), (4, 4), (2, 2)]),
('2', [(3, 3), (1, 4), (2, 2)]),
('3', [(3, 2), (1, 1), (2, 2)]),
('4', [(None, None), (4, 4), (2, 2)]),
('5', [(3, 3), (4, 4), (2, 2)])]]
>>>Remove a locus by position,
>>> record.remove_locus_by_position(0)
>>> record.loci_list
['136257048', '136257636']
>>> record.populations
[[('b1', [(4, 4), (2, 2)]), ('b2', [(4, 4), (2, 2)]), ('b3', [(4, 4), (2, 2)])],
[('1', [(4, 4), (2, 2)]), ('2', [(1, 4), (2, 2)]),
('3', [(1, 1), (2, 2)]), ('4', [(4, 4), (2, 2)]), ('5', [(4, 4), (2, 2)])]]
>>>Remove a locus by name,
>>> record.remove_locus_by_name('136257636') >>> record.loci_list
['136257048']
>>> record.populations
[[('b1', [(4, 4)]), ('b2', [(4, 4)]), ('b3', [(4, 4)])],
[('1', [(4, 4)]), ('2', [(1, 4)]),
('3', [(1, 1)]), ('4', [(4, 4)]), ('5', [(4, 4)])]]
>>>Schnittstelle mit GenePop Software
Biopython bietet Schnittstellen für die Interaktion mit der GenePop-Software und stellt dadurch viele Funktionen zur Verfügung. Zu diesem Zweck wird das Bio.PopGen.GenePop-Modul verwendet. Eine solche benutzerfreundliche Oberfläche ist EasyController. Lassen Sie uns überprüfen, wie die GenePop-Datei analysiert und mit EasyController analysiert wird.
Installieren Sie zunächst die GenePop-Software und legen Sie den Installationsordner im Systempfad ab. Um grundlegende Informationen zur GenePop-Datei zu erhalten, erstellen Sie ein EasyController-Objekt und rufen Sie dann die unten angegebene Methode get_basic_info auf.
>>> from Bio.PopGen.GenePop.EasyController import EasyController
>>> ec = EasyController('c3line.gen')
>>> print(ec.get_basic_info())
(['4', 'b3', '5'], ['136255903', '136257048', '136257636'])
>>>Hier ist das erste Element die Bevölkerungsliste und das zweite Element die Ortsliste.
Um die gesamte Allelliste eines bestimmten Locus abzurufen, rufen Sie die Methode get_alleles_all_pops auf, indem Sie den Locus-Namen wie unten angegeben übergeben.
>>> allele_list = ec.get_alleles_all_pops("136255903")
>>> print(allele_list)
[2, 3]Um die Allelliste nach bestimmter Population und Ort zu erhalten, rufen Sie get_alleles auf, indem Sie den Namen des Ortes und die Position der Bevölkerung wie unten angegeben übergeben.
>>> allele_list = ec.get_alleles(0, "136255903")
>>> print(allele_list)
[]
>>> allele_list = ec.get_alleles(1, "136255903")
>>> print(allele_list)
[]
>>> allele_list = ec.get_alleles(2, "136255903")
>>> print(allele_list)
[2, 3]
>>>In ähnlicher Weise stellt EasyController viele Funktionen zur Verfügung: Allelfrequenz, Genotypfrequenz, Multilocus-F-Statistik, Hardy-Weinberg-Gleichgewicht, Verknüpfungsungleichgewicht usw.
Ein Genom ist ein vollständiger DNA-Satz, einschließlich aller seiner Gene. Die Genomanalyse bezieht sich auf die Untersuchung einzelner Gene und ihrer Rolle bei der Vererbung.
Genomdiagramm
Das Genomdiagramm repräsentiert die genetische Information als Diagramme. Biopython verwendet das Modul Bio.Graphics.GenomeDiagram, um GenomeDiagram darzustellen. Für das GenomeDiagram-Modul muss ReportLab installiert sein.
Schritte zum Erstellen eines Diagramms
Der Prozess der Erstellung eines Diagramms folgt im Allgemeinen dem folgenden einfachen Muster:
Erstellen Sie ein FeatureSet für jeden einzelnen Satz von Features, die Sie anzeigen möchten, und fügen Sie ihnen Bio.SeqFeature-Objekte hinzu.
Erstellen Sie ein GraphSet für jedes Diagramm, das Sie anzeigen möchten, und fügen Sie ihnen Diagrammdaten hinzu.
Erstellen Sie eine Spur für jede Spur, die Sie im Diagramm haben möchten, und fügen Sie den gewünschten Spuren GraphSets und FeatureSets hinzu.
Erstellen Sie ein Diagramm und fügen Sie die Spuren hinzu.
Sagen Sie dem Diagramm, dass es das Bild zeichnen soll.
Schreiben Sie das Bild in eine Datei.
Nehmen wir ein Beispiel für die Eingabe einer GenBank-Datei -
https://raw.githubusercontent.com/biopython/biopython/master/Doc/examples/ls_orchid.gbkLesen Sie die Datensätze aus dem SeqRecord-Objekt und zeichnen Sie schließlich ein Genomdiagramm. Es wird unten erklärt,
Wir werden zuerst alle Module wie unten gezeigt importieren -
>>> from reportlab.lib import colors
>>> from reportlab.lib.units import cm
>>> from Bio.Graphics import GenomeDiagramImportieren Sie nun das SeqIO-Modul, um Daten zu lesen -
>>> from Bio import SeqIO
record = SeqIO.read("example.gb", "genbank")Hier liest der Datensatz die Sequenz aus der Genbank-Datei.
Erstellen Sie nun ein leeres Diagramm, um Titel und Funktionsumfang hinzuzufügen -
>>> diagram = GenomeDiagram.Diagram(
"Yersinia pestis biovar Microtus plasmid pPCP1")
>>> track = diagram.new_track(1, name="Annotated Features")
>>> feature = track.new_set()Jetzt können wir Farbthemaänderungen mit alternativen Farben von Grün nach Grau anwenden, wie unten definiert -
>>> for feature in record.features:
>>> if feature.type != "gene":
>>> continue
>>> if len(feature) % 2 == 0:
>>> color = colors.blue
>>> else:
>>> color = colors.red
>>>
>>> feature.add_feature(feature, color=color, label=True)Jetzt konnten Sie die folgende Antwort auf Ihrem Bildschirm sehen -
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x105d3dc90>
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x105d3dfd0>
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x1007627d0>
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x105d57290>
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x105d57050>
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x105d57390>
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x105d57590>
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x105d57410>
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x105d57490>
<Bio.Graphics.GenomeDiagram._Feature.Feature object at 0x105d574d0>Zeichnen wir ein Diagramm für die obigen Eingabedatensätze -
>>> diagram.draw(
format = "linear", orientation = "landscape", pagesize = 'A4',
... fragments = 4, start = 0, end = len(record))
>>> diagram.write("orchid.pdf", "PDF")
>>> diagram.write("orchid.eps", "EPS")
>>> diagram.write("orchid.svg", "SVG")
>>> diagram.write("orchid.png", "PNG")Nachdem Sie den obigen Befehl ausgeführt haben, wird das folgende Bild in Ihrem Biopython-Verzeichnis gespeichert.
** Result **
genome.png
Sie können das Bild auch im Kreisformat zeichnen, indem Sie die folgenden Änderungen vornehmen:
>>> diagram.draw(
format = "circular", circular = True, pagesize = (20*cm,20*cm),
... start = 0, end = len(record), circle_core = 0.7)
>>> diagram.write("circular.pdf", "PDF")Chromosomenübersicht
Das DNA-Molekül ist in fadenförmige Strukturen verpackt, die als Chromosomen bezeichnet werden. Jedes Chromosom besteht aus DNA, die viele Male eng um Proteine gewickelt ist, die Histone genannt werden und seine Struktur unterstützen.
Chromosomen sind im Zellkern nicht sichtbar - auch nicht unter dem Mikroskop -, wenn sich die Zelle nicht teilt. Die DNA, aus der die Chromosomen bestehen, wird jedoch während der Zellteilung dichter gepackt und ist dann unter einem Mikroskop sichtbar.
Beim Menschen enthält jede Zelle normalerweise 23 Chromosomenpaare, also insgesamt 46. Zweiundzwanzig dieser Paare, Autososomen genannt, sehen bei Männern und Frauen gleich aus. Das 23. Paar, die Geschlechtschromosomen, unterscheiden sich zwischen Männern und Frauen. Frauen haben zwei Kopien des X-Chromosoms, während Männer ein X- und ein Y-Chromosom haben.
Der Phänotyp ist definiert als ein beobachtbarer Charakter oder ein Merkmal, das ein Organismus gegen eine bestimmte Chemikalie oder Umgebung aufweist. Der Phänotyp-Microarray misst gleichzeitig die Reaktion eines Organismus gegen eine größere Anzahl von Chemikalien und die Umwelt und analysiert die Daten, um die Genmutation, die Gencharakteristika usw. zu verstehen.
Biopython bietet mit Bio.Phenotype ein hervorragendes Modul zur Analyse phänotypischer Daten. In diesem Kapitel erfahren Sie, wie Sie die Phänotyp-Microarray-Daten analysieren, interpolieren, extrahieren und analysieren.
Parsing
Phänotyp-Microarray-Daten können in zwei Formaten vorliegen: CSV und JSON. Biopython unterstützt beide Formate. Der Biopython-Parser analysiert die Phänotyp-Microarray-Daten und gibt sie als Sammlung von PlateRecord-Objekten zurück. Jedes PlateRecord-Objekt enthält eine Sammlung von WellRecord-Objekten. Jedes WellRecord-Objekt enthält Daten in 8 Zeilen und 12 Spalten. Die acht Zeilen werden mit A bis H und 12 Spalten dargestellt werden von 01 bis 12 ist beispielsweise dargestellt, 4 th Reihe und 6 - ten Spalte von D06 repräsentiert werden.
Lassen Sie uns das Format und das Konzept des Parsens anhand des folgenden Beispiels verstehen:
Step 1 - Laden Sie die vom Biopython-Team bereitgestellte Datei Plates.csv herunter. - https://raw.githubusercontent.com/biopython/biopython/master/Doc/examples/Plates.csv
Step 2 - Laden Sie das Phenotpe-Modul wie folgt -
>>> from Bio import phenotypeStep 3- Rufen Sie die Methode phänotype.parse auf, die die Option für Datendatei und Format („pm-csv“) übergibt. Es gibt den iterierbaren PlateRecord wie folgt zurück:
>>> plates = list(phenotype.parse('Plates.csv', "pm-csv"))
>>> plates
[PlateRecord('WellRecord['A01'], WellRecord['A02'], WellRecord['A03'], ..., WellRecord['H12']'),
PlateRecord('WellRecord['A01'], WellRecord['A02'], WellRecord['A03'], ..., WellRecord['H12']'),
PlateRecord('WellRecord['A01'], WellRecord['A02'], WellRecord['A03'], ..., WellRecord['H12']'),
PlateRecord('WellRecord['A01'], WellRecord['A02'],WellRecord['A03'], ..., WellRecord['H12']')]
>>>Step 4 - Greifen Sie wie folgt auf die erste Platte aus der Liste zu. -
>>> plate = plates[0]
>>> plate
PlateRecord('WellRecord['A01'], WellRecord['A02'], WellRecord['A03'], ...,
WellRecord['H12']')
>>>Step 5- Wie bereits erwähnt, enthält eine Platte 8 Reihen mit jeweils 12 Elementen. Auf WellRecord kann auf zwei Arten zugegriffen werden, wie unten angegeben -
>>> well = plate["A04"]
>>> well = plate[0, 4]
>>> well WellRecord('(0.0, 0.0), (0.25, 0.0), (0.5, 0.0), (0.75, 0.0),
(1.0, 0.0), ..., (71.75, 388.0)')
>>>Step 6 - Jede Vertiefung hat zu verschiedenen Zeitpunkten eine Reihe von Messungen und kann mit der for-Schleife wie unten angegeben aufgerufen werden. -
>>> for v1, v2 in well:
... print(v1, v2)
...
0.0 0.0
0.25 0.0
0.5 0.0
0.75 0.0
1.0 0.0
...
71.25 388.0
71.5 388.0
71.75 388.0
>>>Interpolation
Die Interpolation gibt mehr Einblick in die Daten. Biopython bietet Methoden zum Interpolieren von WellRecord-Daten, um Informationen für Zwischenzeitpunkte zu erhalten. Die Syntax ähnelt der Listenindizierung und ist daher leicht zu erlernen.
Um die Daten nach 20,1 Stunden zu erhalten, übergeben Sie einfach die unten angegebenen Indexwerte.
>>> well[20.10]
69.40000000000003
>>>Wir können den Startzeitpunkt und den Endzeitpunkt sowie die unten angegebenen Werte überschreiten.
>>> well[20:30]
[67.0, 84.0, 102.0, 119.0, 135.0, 147.0, 158.0, 168.0, 179.0, 186.0]
>>>Der obige Befehl interpoliert Daten von 20 Stunden bis 30 Stunden im Abstand von 1 Stunde. Standardmäßig beträgt das Intervall 1 Stunde und wir können es auf einen beliebigen Wert ändern. Geben wir zum Beispiel ein Intervall von 15 Minuten (0,25 Stunden) an, wie unten angegeben -
>>> well[20:21:0.25]
[67.0, 73.0, 75.0, 81.0]
>>>Analysieren und extrahieren
Biopython bietet eine Methode zur Analyse der WellRecord-Daten mithilfe der Sigmoid-Funktionen von Gompertz, Logistic und Richards. Standardmäßig verwendet die Anpassungsmethode die Gompertz-Funktion. Wir müssen die Anpassungsmethode des WellRecord-Objekts aufrufen, um die Aufgabe zu erledigen. Die Codierung ist wie folgt -
>>> well.fit()
Traceback (most recent call last):
...
Bio.MissingPythonDependencyError: Install scipy to extract curve parameters.
>>> well.model
>>> getattr(well, 'min') 0.0
>>> getattr(well, 'max') 388.0
>>> getattr(well, 'average_height')
205.42708333333334
>>>Biopython hängt vom Scipy-Modul ab, um erweiterte Analysen durchzuführen. Es werden Details zu Min, Max und Average_Hight ohne Verwendung des Scipy-Moduls berechnet.
In diesem Kapitel wird das Zeichnen von Sequenzen erläutert. Bevor wir zu diesem Thema übergehen, wollen wir die Grundlagen des Zeichnens verstehen.
Plotten
Matplotlib ist eine Python-Plotbibliothek, die Qualitätsfiguren in verschiedenen Formaten erstellt. Wir können verschiedene Arten von Plots wie Liniendiagramme, Histogramme, Balkendiagramme, Kreisdiagramme, Streudiagramme usw. erstellen.
pyLab is a module that belongs to the matplotlib which combines the numerical module numpy with the graphical plotting module pyplot.Biopython verwendet das Pylab-Modul zum Zeichnen von Sequenzen. Dazu müssen wir den folgenden Code importieren -
import pylabVor dem Importieren müssen wir das matplotlib-Paket mit dem Befehl pip mit dem folgenden Befehl installieren -
pip install matplotlibBeispiel-Eingabedatei
Erstellen Sie eine Beispieldatei mit dem Namen plot.fasta in Ihrem Biopython-Verzeichnis und fügen Sie die folgenden Änderungen hinzu -
>seq0 FQTWEEFSRAAEKLYLADPMKVRVVLKYRHVDGNLCIKVTDDLVCLVYRTDQAQDVKKIEKF
>seq1 KYRTWEEFTRAAEKLYQADPMKVRVVLKYRHCDGNLCIKVTDDVVCLLYRTDQAQDVKKIEKFHSQLMRLME
>seq2 EEYQTWEEFARAAEKLYLTDPMKVRVVLKYRHCDGNLCMKVTDDAVCLQYKTDQAQDVKKVEKLHGK
>seq3 MYQVWEEFSRAVEKLYLTDPMKVRVVLKYRHCDGNLCIKVTDNSVCLQYKTDQAQDV
>seq4 EEFSRAVEKLYLTDPMKVRVVLKYRHCDGNLCIKVTDNSVVSYEMRLFGVQKDNFALEHSLL
>seq5 SWEEFAKAAEVLYLEDPMKCRMCTKYRHVDHKLVVKLTDNHTVLKYVTDMAQDVKKIEKLTTLLMR
>seq6 FTNWEEFAKAAERLHSANPEKCRFVTKYNHTKGELVLKLTDDVVCLQYSTNQLQDVKKLEKLSSTLLRSI
>seq7 SWEEFVERSVQLFRGDPNATRYVMKYRHCEGKLVLKVTDDRECLKFKTDQAQDAKKMEKLNNIFF
>seq8 SWDEFVDRSVQLFRADPESTRYVMKYRHCDGKLVLKVTDNKECLKFKTDQAQEAKKMEKLNNIFFTLM
>seq9 KNWEDFEIAAENMYMANPQNCRYTMKYVHSKGHILLKMSDNVKCVQYRAENMPDLKK
>seq10 FDSWDEFVSKSVELFRNHPDTTRYVVKYRHCEGKLVLKVTDNHECLKFKTDQAQDAKKMEKLiniendiagramm
Lassen Sie uns nun ein einfaches Liniendiagramm für die obige Fasta-Datei erstellen.
Step 1 - Importieren Sie das SeqIO-Modul, um die Fasta-Datei zu lesen.
>>> from Bio import SeqIOStep 2 - Analysieren Sie die Eingabedatei.
>>> records = [len(rec) for rec in SeqIO.parse("plot.fasta", "fasta")]
>>> len(records)
11
>>> max(records)
72
>>> min(records)
57Step 3 - Importieren wir das Pylab-Modul.
>>> import pylabStep 4 - Konfigurieren Sie das Liniendiagramm, indem Sie Beschriftungen für die x- und y-Achse zuweisen.
>>> pylab.xlabel("sequence length")
Text(0.5, 0, 'sequence length')
>>> pylab.ylabel("count")
Text(0, 0.5, 'count')
>>>Step 5 - Konfigurieren Sie das Liniendiagramm, indem Sie die Rasteranzeige einstellen.
>>> pylab.grid()Step 6 - Zeichnen Sie ein einfaches Liniendiagramm, indem Sie die Plotmethode aufrufen und Datensätze als Eingabe bereitstellen.
>>> pylab.plot(records)
[<matplotlib.lines.Line2D object at 0x10b6869d 0>]Step 7 - Speichern Sie das Diagramm abschließend mit dem folgenden Befehl.
>>> pylab.savefig("lines.png")Ergebnis
Nachdem Sie den obigen Befehl ausgeführt haben, wird das folgende Bild in Ihrem Biopython-Verzeichnis gespeichert.
Histogramm-Diagramm
Ein Histogramm wird für kontinuierliche Daten verwendet, wobei die Bins Datenbereiche darstellen. Das Zeichnungshistogramm entspricht dem Liniendiagramm mit Ausnahme von pylab.plot. Rufen Sie stattdessen die hist-Methode des Pylab-Moduls mit Datensätzen und einem Custum-Wert für Bins auf (5). Die vollständige Codierung lautet wie folgt:
Step 1 - Importieren Sie das SeqIO-Modul, um die Fasta-Datei zu lesen.
>>> from Bio import SeqIOStep 2 - Analysieren Sie die Eingabedatei.
>>> records = [len(rec) for rec in SeqIO.parse("plot.fasta", "fasta")]
>>> len(records)
11
>>> max(records)
72
>>> min(records)
57Step 3 - Importieren wir das Pylab-Modul.
>>> import pylabStep 4 - Konfigurieren Sie das Liniendiagramm, indem Sie Beschriftungen für die x- und y-Achse zuweisen.
>>> pylab.xlabel("sequence length")
Text(0.5, 0, 'sequence length')
>>> pylab.ylabel("count")
Text(0, 0.5, 'count')
>>>Step 5 - Konfigurieren Sie das Liniendiagramm, indem Sie die Rasteranzeige einstellen.
>>> pylab.grid()Step 6 - Zeichnen Sie ein einfaches Liniendiagramm, indem Sie die Plotmethode aufrufen und Datensätze als Eingabe bereitstellen.
>>> pylab.hist(records,bins=5)
(array([2., 3., 1., 3., 2.]), array([57., 60., 63., 66., 69., 72.]), <a list
of 5 Patch objects>)
>>>Step 7 - Speichern Sie das Diagramm abschließend mit dem folgenden Befehl.
>>> pylab.savefig("hist.png")Ergebnis
Nachdem Sie den obigen Befehl ausgeführt haben, wird das folgende Bild in Ihrem Biopython-Verzeichnis gespeichert.
GC-Prozentsatz in Sequenz
Der GC-Prozentsatz ist eine der häufig verwendeten Analysedaten zum Vergleich verschiedener Sequenzen. Wir können ein einfaches Liniendiagramm mit dem GC-Prozentsatz einer Reihe von Sequenzen erstellen und es sofort vergleichen. Hier können wir einfach die Daten von der Sequenzlänge in den GC-Prozentsatz ändern. Die vollständige Codierung ist unten angegeben -
Step 1 - Importieren Sie das SeqIO-Modul, um die Fasta-Datei zu lesen.
>>> from Bio import SeqIOStep 2 - Analysieren Sie die Eingabedatei.
>>> from Bio.SeqUtils import GC
>>> gc = sorted(GC(rec.seq) for rec in SeqIO.parse("plot.fasta", "fasta"))Step 3 - Importieren wir das Pylab-Modul.
>>> import pylabStep 4 - Konfigurieren Sie das Liniendiagramm, indem Sie Beschriftungen für die x- und y-Achse zuweisen.
>>> pylab.xlabel("Genes")
Text(0.5, 0, 'Genes')
>>> pylab.ylabel("GC Percentage")
Text(0, 0.5, 'GC Percentage')
>>>Step 5 - Konfigurieren Sie das Liniendiagramm, indem Sie die Rasteranzeige einstellen.
>>> pylab.grid()Step 6 - Zeichnen Sie ein einfaches Liniendiagramm, indem Sie die Plotmethode aufrufen und Datensätze als Eingabe bereitstellen.
>>> pylab.plot(gc)
[<matplotlib.lines.Line2D object at 0x10b6869d 0>]Step 7 - Speichern Sie das Diagramm abschließend mit dem folgenden Befehl.
>>> pylab.savefig("gc.png")Ergebnis
Nachdem Sie den obigen Befehl ausgeführt haben, wird das folgende Bild in Ihrem Biopython-Verzeichnis gespeichert.
Im Allgemeinen gruppiert die Clusteranalyse eine Reihe von Objekten in derselben Gruppe. Dieses Konzept wird hauptsächlich beim Data Mining, bei der statistischen Datenanalyse, beim maschinellen Lernen, bei der Mustererkennung, bei der Bildanalyse, bei der Bioinformatik usw. verwendet. Es kann durch verschiedene Algorithmen erreicht werden, um zu verstehen, wie häufig der Cluster in verschiedenen Analysen verwendet wird.
Laut Bioinformatics wird die Clusteranalyse hauptsächlich in der Analyse von Genexpressionsdaten verwendet, um Gruppen von Genen mit ähnlicher Genexpression zu finden.
In diesem Kapitel werden wichtige Algorithmen in Biopython untersucht, um die Grundlagen des Clustering in einem realen Datensatz zu verstehen.
Biopython verwendet das Bio.Cluster-Modul zur Implementierung aller Algorithmen. Es unterstützt die folgenden Algorithmen:
- Hierarchisches Clustering
- K - Clustering
- Selbstorganisierende Karten
- Hauptkomponentenanalyse
Lassen Sie uns eine kurze Einführung in die oben genannten Algorithmen geben.
Hierarchisches Clustering
Hierarchisches Clustering wird verwendet, um jeden Knoten durch ein Abstandsmaß mit seinem nächsten Nachbarn zu verbinden und einen Cluster zu erstellen. Der Bio.Cluster-Knoten hat drei Attribute: links, rechts und Abstand. Erstellen wir einen einfachen Cluster wie unten gezeigt -
>>> from Bio.Cluster import Node
>>> n = Node(1,10)
>>> n.left = 11
>>> n.right = 0
>>> n.distance = 1
>>> print(n)
(11, 0): 1Wenn Sie ein baumbasiertes Clustering erstellen möchten, verwenden Sie den folgenden Befehl:
>>> n1 = [Node(1, 2, 0.2), Node(0, -1, 0.5)] >>> n1_tree = Tree(n1)
>>> print(n1_tree)
(1, 2): 0.2
(0, -1): 0.5
>>> print(n1_tree[0])
(1, 2): 0.2Lassen Sie uns mit dem Bio.Cluster-Modul hierarchisches Clustering durchführen.
Beachten Sie, dass der Abstand in einem Array definiert ist.
>>> import numpy as np
>>> distance = array([[1,2,3],[4,5,6],[3,5,7]])Fügen Sie nun das Distanzarray im Baumcluster hinzu.
>>> from Bio.Cluster import treecluster
>>> cluster = treecluster(distance)
>>> print(cluster)
(2, 1): 0.666667
(-1, 0): 9.66667Die obige Funktion gibt ein Tree-Cluster-Objekt zurück. Dieses Objekt enthält Knoten, bei denen die Anzahl der Elemente als Zeilen oder Spalten gruppiert ist.
K - Clustering
Es ist eine Art Partitionierungsalgorithmus, der in k - Mittelwerte, Mediane und Medoidencluster unterteilt ist. Lassen Sie uns die einzelnen Cluster kurz verstehen.
K-bedeutet Clustering
Dieser Ansatz ist im Data Mining beliebt. Das Ziel dieses Algorithmus ist es, Gruppen in den Daten zu finden, wobei die Anzahl der Gruppen durch die Variable K dargestellt wird.
Der Algorithmus arbeitet iterativ, um jeden Datenpunkt basierend auf den bereitgestellten Funktionen einer der K Gruppen zuzuweisen. Datenpunkte werden basierend auf der Ähnlichkeit der Merkmale gruppiert.
>>> from Bio.Cluster import kcluster
>>> from numpy import array
>>> data = array([[1, 2], [3, 4], [5, 6]])
>>> clusterid, error,found = kcluster(data)
>>> print(clusterid) [0 0 1]
>>> print(found)
1K-Mediane Clustering
Es ist eine andere Art von Clustering-Algorithmus, der den Mittelwert für jeden Cluster berechnet, um seinen Schwerpunkt zu bestimmen.
K-Medoide Clustering
Dieser Ansatz basiert auf einem bestimmten Satz von Elementen unter Verwendung der Abstandsmatrix und der Anzahl der vom Benutzer übergebenen Cluster.
Betrachten Sie die unten definierte Distanzmatrix -
>>> distance = array([[1,2,3],[4,5,6],[3,5,7]])Wir können die Clusterbildung von k-Medoiden mit dem folgenden Befehl berechnen:
>>> from Bio.Cluster import kmedoids
>>> clusterid, error, found = kmedoids(distance)Betrachten wir ein Beispiel.
Die kcluster-Funktion verwendet eine Datenmatrix als Eingabe und keine Seq-Instanzen. Sie müssen Ihre Sequenzen in eine Matrix konvertieren und diese für die kcluster-Funktion bereitstellen.
Eine Möglichkeit, die Daten in eine Matrix zu konvertieren, die nur numerische Elemente enthält, ist die Verwendung von numpy.fromstringFunktion. Grundsätzlich übersetzt es jeden Buchstaben in einer Sequenz in sein ASCII-Gegenstück.
Dadurch wird ein 2D-Array von codierten Sequenzen erstellt, die von der kcluster-Funktion erkannt und zum Clustering Ihrer Sequenzen verwendet werden.
>>> from Bio.Cluster import kcluster
>>> import numpy as np
>>> sequence = [ 'AGCT','CGTA','AAGT','TCCG']
>>> matrix = np.asarray([np.fromstring(s, dtype=np.uint8) for s in sequence])
>>> clusterid,error,found = kcluster(matrix)
>>> print(clusterid) [1 0 0 1]Selbstorganisierende Karten
Dieser Ansatz ist eine Art künstliches neuronales Netzwerk. Es wird von Kohonen entwickelt und oft als Kohonen-Karte bezeichnet. Es organisiert Elemente in Clustern basierend auf der rechteckigen Topologie.
Erstellen wir einen einfachen Cluster mit demselben Array-Abstand wie unten gezeigt -
>>> from Bio.Cluster import somcluster
>>> from numpy import array
>>> data = array([[1, 2], [3, 4], [5, 6]])
>>> clusterid,map = somcluster(data)
>>> print(map)
[[[-1.36032469 0.38667395]]
[[-0.41170578 1.35295911]]]
>>> print(clusterid)
[[1 0]
[1 0]
[1 0]]Hier, clusterid ist ein Array mit zwei Spalten, wobei die Anzahl der Zeilen der Anzahl der Elemente entspricht, die geclustert wurden, und data ist ein Array mit Dimensionen entweder Zeilen oder Spalten.
Hauptkomponentenanalyse
Die Hauptkomponentenanalyse ist nützlich, um hochdimensionale Daten zu visualisieren. Es ist eine Methode, die einfache Matrixoperationen aus linearer Algebra und Statistik verwendet, um eine Projektion der Originaldaten in dieselbe Anzahl oder weniger Dimensionen zu berechnen.
Die Hauptkomponentenanalyse gibt ein Tupelspaltenmittel, Koordinaten, Komponenten und Eigenwerte zurück. Lassen Sie uns die Grundlagen dieses Konzepts untersuchen.
>>> from numpy import array
>>> from numpy import mean
>>> from numpy import cov
>>> from numpy.linalg import eig
# define a matrix
>>> A = array([[1, 2], [3, 4], [5, 6]])
>>> print(A)
[[1 2]
[3 4]
[5 6]]
# calculate the mean of each column
>>> M = mean(A.T, axis = 1)
>>> print(M)
[ 3. 4.]
# center columns by subtracting column means
>>> C = A - M
>>> print(C)
[[-2. -2.]
[ 0. 0.]
[ 2. 2.]]
# calculate covariance matrix of centered matrix
>>> V = cov(C.T)
>>> print(V)
[[ 4. 4.]
[ 4. 4.]]
# eigendecomposition of covariance matrix
>>> values, vectors = eig(V)
>>> print(vectors)
[[ 0.70710678 -0.70710678]
[ 0.70710678 0.70710678]]
>>> print(values)
[ 8. 0.]Wenden wir die gleichen rechteckigen Matrixdaten auf das Bio.Cluster-Modul an, wie unten definiert -
>>> from Bio.Cluster import pca
>>> from numpy import array
>>> data = array([[1, 2], [3, 4], [5, 6]])
>>> columnmean, coordinates, components, eigenvalues = pca(data)
>>> print(columnmean)
[ 3. 4.]
>>> print(coordinates)
[[-2.82842712 0. ]
[ 0. 0. ]
[ 2.82842712 0. ]]
>>> print(components)
[[ 0.70710678 0.70710678]
[ 0.70710678 -0.70710678]]
>>> print(eigenvalues)
[ 4. 0.]Die Bioinformatik ist ein ausgezeichneter Bereich für die Anwendung von Algorithmen für maschinelles Lernen. Hier haben wir genetische Informationen über eine große Anzahl von Organismen und es ist nicht möglich, alle diese Informationen manuell zu analysieren. Wenn ein geeigneter Algorithmus für maschinelles Lernen verwendet wird, können wir aus diesen Daten viele nützliche Informationen extrahieren. Biopython bietet nützliche Algorithmen für überwachtes maschinelles Lernen.
Das überwachte Lernen basiert auf der Eingangsvariablen (X) und der Ausgangsvariablen (Y). Es verwendet einen Algorithmus, um die Zuordnungsfunktion von der Eingabe zur Ausgabe zu lernen. Es ist unten definiert -
Y = f(X)Das Hauptziel dieses Ansatzes besteht darin, die Zuordnungsfunktion zu approximieren. Wenn Sie neue Eingabedaten (x) haben, können Sie die Ausgabevariablen (Y) für diese Daten vorhersagen.
Logistisches Regressionsmodell
Die logistische Regression ist ein überwachter Algorithmus für maschinelles Lernen. Es wird verwendet, um den Unterschied zwischen K Klassen unter Verwendung einer gewichteten Summe von Prädiktorvariablen herauszufinden. Es berechnet die Wahrscheinlichkeit des Auftretens eines Ereignisses und kann zur Krebserkennung verwendet werden.
Biopython bietet das Modul Bio.LogisticRegression zur Vorhersage von Variablen basierend auf dem logistischen Regressionsalgorithmus. Derzeit implementiert Biopython den logistischen Regressionsalgorithmus nur für zwei Klassen (K = 2).
k-Nächste Nachbarn
k-Nearest Nachbarn ist auch ein überwachter Algorithmus für maschinelles Lernen. Es funktioniert durch Kategorisieren der Daten basierend auf den nächsten Nachbarn. Biopython bietet das Bio.KNN-Modul zur Vorhersage von Variablen basierend auf dem Algorithmus für k-nächste Nachbarn.
Naive Bayes
Naive Bayes-Klassifikatoren sind eine Sammlung von Klassifikationsalgorithmen, die auf dem Bayes-Theorem basieren. Es ist kein einzelner Algorithmus, sondern eine Familie von Algorithmen, bei denen alle ein gemeinsames Prinzip haben, dh jedes zu klassifizierende Merkmalspaar ist unabhängig voneinander. Biopython bietet das Bio.NaiveBayes-Modul für die Arbeit mit dem Naive Bayes-Algorithmus.
Markov-Modell
Ein Markov-Modell ist ein mathematisches System, das als Sammlung von Zufallsvariablen definiert ist und nach bestimmten Wahrscheinlichkeitsregeln einen Übergang von einem Zustand in einen anderen erfährt. Biopython bietetBio.MarkovModel and Bio.HMM.MarkovModel modules to work with Markov models.
Biopython verfügt über ein umfangreiches Testskript zum Testen der Software unter verschiedenen Bedingungen, um sicherzustellen, dass die Software fehlerfrei ist. Laden Sie zum Ausführen des Testskripts den Quellcode von Biopython herunter und führen Sie dann den folgenden Befehl aus:
python run_tests.pyDadurch werden alle Testskripte ausgeführt und die folgende Ausgabe ausgegeben:
Python version: 2.7.12 (v2.7.12:d33e0cf91556, Jun 26 2016, 12:10:39)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)]
Operating system: posix darwin
test_Ace ... ok
test_Affy ... ok
test_AlignIO ... ok
test_AlignIO_ClustalIO ... ok
test_AlignIO_EmbossIO ... ok
test_AlignIO_FastaIO ... ok
test_AlignIO_MauveIO ... ok
test_AlignIO_PhylipIO ... ok
test_AlignIO_convert ... ok
...........................................
...........................................Wir können auch ein einzelnes Testskript ausführen, wie unten angegeben -
python test_AlignIO.pyFazit
Wie wir gelernt haben, ist Biopython eine der wichtigsten Software auf dem Gebiet der Bioinformatik. Da es in Python geschrieben ist (leicht zu erlernen und zu schreiben), bietet es umfangreiche Funktionen für alle Berechnungen und Operationen im Bereich der Bioinformatik. Es bietet auch eine einfache und flexible Schnittstelle zu fast allen gängigen Bioinformatik-Programmen, um auch deren Funktionalität zu nutzen.