Biopython-quick-guide
Biopython-はじめに
Biopythonは、Python用の最大かつ最も人気のあるバイオインフォマティクスパッケージです。 一般的なバイオインフォマティクスタスク用のさまざまなサブモジュールが含まれています。 主にPythonで書かれたChapmanとChangによって開発されました。 また、ソフトウェアの複雑な計算部分を最適化するCコードも含まれています。 Windows、Linux、Mac OS Xなどで実行されます。
基本的に、Biopythonは、DNA文字列の逆補完、タンパク質配列のモチーフの検索など、DNA、RNAおよびタンパク質配列の操作を処理する機能を提供するPythonモジュールのコレクションです。 GenBank、SwissPort、FASTAなどのすべての主要な遺伝的データベースを読み取るための多くのパーサーと、Python環境内でNCBI BLASTN、Entrezなどの他の一般的なバイオインフォマティクスソフトウェア/ツールを実行するためのラッパー/インターフェイスを提供します。 BioPerl、BioJava、BioRubyなどの兄弟プロジェクトがあります。
特徴
Biopythonは移植性があり、明確で、構文を習得しやすいです。 顕著な特徴のいくつかを以下に示します-
- 解釈されたインタラクティブなオブジェクト指向。
- FASTA、PDB、GenBank、Blast、SCOP、PubMed/Medline、ExPASy関連の形式をサポートしています。
- シーケンス形式を処理するオプション。
- タンパク質構造を管理するツール。
- BioSQL-シーケンスと機能および注釈を保存するためのSQLテーブルの標準セット。
- NCBIサービス（Blast、Entrez、PubMed）およびExPASYサービス（SwissProt、Prosite）を含むオンラインサービスおよびデータベースへのアクセス。
- Blast、Clustalw、EMBOSSなどのローカルサービスへのアクセス。
目標
Biopythonの目標は、Python言語を介したバイオインフォマティクスへのシンプルで標準的な広範なアクセスを提供することです。 Biopythonの具体的な目標は以下のとおりです-
- バイオインフォマティクスリソースへの標準化されたアクセスを提供します。
- 高品質で再利用可能なモジュールとスクリプト。
- クラスタコード、PDB、NaiveBayes、およびマルコフモデルで使用できる高速配列操作。
- ゲノムデータ分析。
利点
Biopythonは必要なコードが非常に少なく、次の利点があります-
- クラスタリングで使用されるマイクロアレイデータタイプを提供します。
- ツリービュータイプのファイルを読み書きします。
- PDBの解析、表現、分析に使用される構造データをサポートします。
- Medlineアプリケーションで使用されるジャーナルデータをサポートします。
- すべてのバイオインフォマティクスプロジェクトで広く使用されている標準データベースであるBioSQLデータベースをサポートします。
- バイオインフォマティクスファイルを_format固有のレコードオブジェクトまたはシーケンスと機能の汎用クラスに解析するモジュールを提供することにより、パーサー開発をサポートします。
- クックブックスタイルに基づく明確なドキュメント。
サンプルケーススタディ
私たちはいくつかのユースケース（集団遺伝学、RNA構造など）をチェックし、この分野でBiopythonがどのように重要な役割を果たしているかを理解してみましょう-
集団遺伝学
集団遺伝学は、集団内の遺伝的変異の研究であり、空間および時間にわたる集団の遺伝子および対立遺伝子の頻度の変化の調査およびモデリングを伴います。
Biopythonは、集団遺伝学用のBio.PopGenモジュールを提供します。 このモジュールには、古典的な集団遺伝学に関する情報を収集するために必要なすべての機能が含まれています。
RNA構造
私たちの生活に不可欠な3つの主要な生体高分子は、DNA、RNA、タンパク質です。 タンパク質は細胞の働き者であり、酵素として重要な役割を果たします。 DNA（デオキシリボ核酸）は、細胞の「青写真」と見なされます。 細胞が成長し、栄養素を取り込み、増殖するために必要なすべての遺伝情報が含まれています。 RNA（リボ核酸）は、細胞内で「DNAコピー」として機能します。
Biopythonは、ヌクレオチド、DNAおよびRNAのビルディングブロックを表すBio.Sequenceオブジェクトを提供します。
Biopython-インストール
このセクションでは、Biopythonをマシンにインストールする方法について説明します。 インストールは非常に簡単で、5分以上かかりません。
- ステップ1 *-Pythonインストールの検証
Biopythonは、Python 2.5以降のバージョンで動作するように設計されています。 そのため、最初にpythonをインストールすることが必須です。 コマンドプロンプトで以下のコマンドを実行します-
> python --version以下に定義されています-
適切にインストールされている場合、Pythonのバージョンが表示されます。 それ以外の場合は、最新バージョンのpythonをダウンロードしてインストールし、コマンドを再実行してください。
- ステップ2 *-pipを使用してBiopythonをインストールする
すべてのプラットフォームでコマンドラインからpipを使用してBiopythonを簡単にインストールできます。 以下のコマンドを入力します-
> pip install biopython次の応答が画面に表示されます-
Biopythonの古いバージョンを更新するには-
> pip install biopython –-upgrade次の応答が画面に表示されます-
このコマンドを実行すると、古いバージョンのBiopythonおよびNumPy（Biopythonはそれに依存します）は、最新バージョンをインストールする前に削除されます。
- ステップ3 *-Biopythonインストールの検証
これで、マシンにBiopythonが正常にインストールされました。 Biopythonが正しくインストールされていることを確認するには、Pythonコンソールで次のコマンドを入力します-
Biopythonのバージョンを示しています。
代替方法-ソースを使用してBiopythonをインストールする
ソースコードを使用してBiopythonをインストールするには、以下の指示に従ってください-
次のリンクからBiopythonの最新リリースをダウンロードします-https://biopython.org/wiki/Download
現在、最新バージョンは biopython-1.72 です。
ファイルをダウンロードし、圧縮アーカイブファイルを解凍し、ソースコードフォルダーに移動して、以下のコマンドを入力します-
> python setup.py buildこれは、以下に示すように、ソースコードからBiopythonをビルドします-
今、以下のコマンドを使用してコードをテストします-
> python setup.py test最後に、以下のコマンドを使用してインストールします-
> python setup.py installBiopython-シンプルなアプリケーションの作成
バイオインフォマティクスファイルを解析してコンテンツを印刷する簡単なBiopythonアプリケーションを作成しましょう。 これは、Biopythonの一般的な概念と、それがバイオインフォマティクスの分野でどのように役立つかを理解するのに役立ちます。
- ステップ1 *-まず、サンプルシーケンスファイル“ example.fasta”を作成し、その中に以下のコンテンツを入れます。
>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
NAGNTIVKTTNGSQLPTNLPLKFITTEGNEHLVSGNYRANITITSTIKGGGTKKGTTDKK拡張子_fasta_は、シーケンスファイルのファイル形式を示します。 FASTAは、バイオインフォマティクスソフトウェアであるFASTAに由来するため、その名前が付けられています。 FASTA形式には複数のシーケンスが1つずつ配置され、各シーケンスには独自のID、名前、説明、実際のシーケンスデータが含まれます。
ステップ2 *-新しいPythonスクリプト simple_example.py "を作成し、以下のコードを入力して保存します。
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)コードをもう少し詳しく見てみましょう-
- 行1 *は、Bio.SeqIOモジュールで利用可能な解析クラスをインポートします。 Bio.SeqIOモジュールは異なる形式のシーケンスファイルの読み取りと書き込みに使用され、「parse」クラスはシーケンスファイルのコンテンツの解析に使用されます。
- 行2 *は、Bio.SeqRecordモジュールで使用可能なSeqRecordクラスをインポートします。 このモジュールはシーケンスレコードの操作に使用され、SeqRecordクラスはシーケンスファイルで使用可能な特定のシーケンスを表すために使用されます。
- 行3 "*は、Bio.Seqモジュールで使用可能なSeqクラスをインポートします。 このモジュールはシーケンスデータを操作するために使用され、Seqクラスはシーケンスファイルで利用可能な特定のシーケンスレコードのシーケンスデータを表すために使用されます。
- 行5 *は、通常のpython関数openを使用して「example.fasta」ファイルを開きます。
- 行7 *は、シーケンスファイルのコンテンツを解析し、そのコンテンツをSeqRecordオブジェクトのリストとして返します。
- 行9-15 *は、Python forループを使用してレコードをループし、ID、名前、説明、シーケンスデータなどのシーケンスレコード（SqlRecord）の属性を出力します。
- 行15 *は、アルファベットクラスを使用してシーケンスのタイプを出力します。
- ステップ3 *-コマンドプロンプトを開き、シーケンスファイル「example.fasta」を含むフォルダーに移動して、以下のコマンドを実行します-
> python simple_example.py- ステップ4 *-Pythonはスクリプトを実行し、サンプルファイル「example.fasta」で使用可能なすべてのシーケンスデータを出力します。 出力は次の内容のようになります。
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()この例では、parse、SeqRecord、Seqの3つのクラスを見てきました。 これらの3つのクラスはほとんどの機能を提供します。これらのクラスについては、次のセクションで学習します。
Biopython-シーケンス
シーケンスは、生物のタンパク質、DNA、またはRNAを表すために使用される一連の文字です。 Seqクラスで表されます。 SeqクラスはBio.Seqモジュールで定義されています。
以下に示すように、Biopythonで簡単なシーケンスを作成しましょう-
>>> from Bio.Seq import Seq
>>> seq = Seq("AGCT")
>>> seq
Seq('AGCT')
>>> print(seq)
AGCTここでは、単純なタンパク質シーケンス AGCT を作成し、各文字は* A ラニン、 G リシン、 C システイン、 T *レオニンを表します。
各Seqオブジェクトには2つの重要な属性があります-
- データ-実際のシーケンス文字列（AGCT）
- アルファベット-シーケンスのタイプを表すために使用されます。 e.g. DNA配列、RNA配列など デフォルトでは、シーケンスを表しておらず、本質的に汎用です。
アルファベットモジュール
Seqオブジェクトには、シーケンスタイプ、文字、および可能な操作を指定するAlphabet属性が含まれています。 Bio.Alphabetモジュールで定義されています。 アルファベットは以下のように定義できます-
>>> from Bio.Seq import Seq
>>> myseq = Seq("AGCT")
>>> myseq
Seq('AGCT')
>>> myseq.alphabet
Alphabet()アルファベットモジュールは、さまざまなタイプのシーケンスを表す以下のクラスを提供します。 アルファベット-すべてのタイプのアルファベットの基本クラス。
SingleLetterAlphabet-サイズ1の文字を含む汎用アルファベット。 それはアルファベットから派生し、他のすべてのアルファベットタイプはそれから派生します。
>>> 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-一般的な単一文字のタンパク質アルファベット。
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_protein
>>> test_seq = Seq('AGTACACTGGT', generic_protein)
>>> test_seq
Seq('AGTACACTGGT', ProteinAlphabet())NucleotideAlphabet-一般的な1文字のヌクレオチドアルファベット。
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_nucleotide
>>> test_seq = Seq('AGTACACTGGT', generic_nucleotide) >>> test_seq
Seq('AGTACACTGGT', NucleotideAlphabet())DNAAlphabet-一般的な1文字のDNAアルファベット。
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_dna
>>> test_seq = Seq('AGTACACTGGT', generic_dna)
>>> test_seq
Seq('AGTACACTGGT', DNAAlphabet())RNAAlphabet-一般的な1文字のRNAアルファベット。
>>> from Bio.Seq import Seq
>>> from Bio.Alphabet import generic_rna
>>> test_seq = Seq('AGTACACTGGT', generic_rna)
>>> test_seq
Seq('AGTACACTGGT', RNAAlphabet())BiopythonモジュールのBio.Alphabet.IUPACは、IUPACコミュニティで定義されている基本的なシーケンスタイプを提供します。 次のクラスが含まれています-
- * IUPACタンパク質（タンパク質）*-20個の標準アミノ酸のIUPACタンパク質アルファベット。
- * ExtendedIUPACProtein（extended_protein）*-Xを含む拡張大文字IUPACタンパク質1文字アルファベット。
- * IUPACAmbiguousDNA（ambiguous_dna）*-大文字のIUPACあいまいなDNA。
- * IUPACUnambiguousDNA（unambiguous_dna）*-大文字のIUPAC unambiguous DNA（GATC）。
- * ExtendedIUPACDNA（extended_dna）*-拡張IUPAC DNAアルファベット。
- * IUPACAmbiguousRNA（ambiguous_rna）*-大文字のIUPAC ambiguous RNA。
- * IUPACUnambiguousRNA（unambiguous_rna）*-大文字のIUPAC unambiguous RNA（GAUC）。
以下に示すように、IUPACProteinクラスの簡単な例を考えてください-
>>> from Bio.Alphabet import IUPAC
>>> protein_seq = Seq("AGCT", IUPAC.protein)
>>> protein_seq
Seq('AGCT', IUPACProtein())
>>> protein_seq.alphabetまた、BiopythonはBio.Dataモジュールを通じてすべてのバイオインフォマティクス関連の構成データを公開します。 たとえば、IUPACData.protein_lettersにはIUPACProteinアルファベットの可能な文字があります。
>>> from Bio.Data import IUPACData
>>> IUPACData.protein_letters
'ACDEFGHIKLMNPQRSTVWY'基本操作
このセクションでは、Seqクラスで使用可能なすべての基本操作について簡単に説明します。 シーケンスはPython文字列に似ています。 シーケンスのスライス、カウント、連結、検索、分割、ストリップなどのPython文字列操作を実行できます。
以下のコードを使用して、さまざまな出力を取得します。
シーケンスの最初の値を取得するには
>>> seq_string = Seq("AGCTAGCT")
>>> seq_string[0]
'A'最初の2つの値を印刷するには。
>>> seq_string[0:2]
Seq('AG')すべての値を印刷するには
>>> seq_string[ : ]
Seq('AGCTAGCT')長さとカウントの操作を実行します。
>>> len(seq_string)
8
>>> seq_string.count('A')
2- 2つのシーケンスを追加します。*
>>> from Bio.Alphabet import generic_dna, generic_protein
>>> seq1 = Seq("AGCT", generic_dna)
>>> seq2 = Seq("TCGA", generic_dna)
>>> seq1+seq2
Seq('AGCTTCGA', DNAAlphabet())ここで、上記の2つのシーケンスオブジェクト、seq1、seq2は汎用のDNAシーケンスであるため、それらを追加して新しいシーケンスを作成できます。 以下に指定されているタンパク質配列やDNA配列など、互換性のないアルファベットを含む配列を追加することはできません-
>>> dna_seq = Seq('AGTACACTGGT', generic_dna)
>>> protein_seq = Seq('AGUACACUGGU', generic_protein)
>>> dna_seq + protein_seq
.....
.....
TypeError: Incompatible alphabets DNAAlphabet() and ProteinAlphabet()
>>>2つ以上のシーケンスを追加するには、まずPythonリストに保存し、次に「forループ」を使用して取得し、最後に以下に示すように一緒に追加します-
>>> 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())以下のセクションでは、要件に基づいて出力を取得するためのさまざまなコードを示します。
シーケンスの大文字小文字を変更するには
>>> from Bio.Alphabet import generic_rna
>>> rna = Seq("agct", generic_rna)
>>> rna.upper()
Seq('AGCT', RNAAlphabet())- PythonメンバーシップとID演算子を確認するには。*
>>> rna = Seq("agct", generic_rna)
>>> 'a' in rna
True
>>> 'A' in rna
False
>>> rna1 = Seq("AGCT", generic_dna)
>>> rna is rna1
False指定されたシーケンス内の単一の文字または文字のシーケンスを検索します。
>>> protein_seq = Seq('AGUACACUGGU', generic_protein)
>>> protein_seq.find('G')
1
>>> protein_seq.find('GG')
8分割操作を実行します。
>>> protein_seq = Seq('AGUACACUGGU', generic_protein)
>>> protein_seq.split('A')
[Seq('', ProteinAlphabet()), Seq('GU', ProteinAlphabet()),
Seq('C', ProteinAlphabet()), Seq('CUGGU', ProteinAlphabet())]シーケンスでストリップ操作を実行します。
>>> strip_seq = Seq(" AGCT ")
>>> strip_seq
Seq(' AGCT ')
>>> strip_seq.strip()
Seq('AGCT')Biopython-高度なシーケンス操作
この章では、Biopythonが提供する高度なシーケンス機能のいくつかについて説明します。
補数および逆補数
ヌクレオチド配列を逆補完して、新しい配列を取得できます。 また、補完されたシーケンスを逆補完して元のシーケンスを取得することもできます。 Biopythonは、この機能を実行するための2つの方法- complement および reverse_complement を提供します。 このためのコードは以下のとおりです-
>>> from Bio.Alphabet import IUPAC
>>> nucleotide = Seq('TCGAAGTCAGTC', IUPAC.ambiguous_dna)
>>> nucleotide.complement()
Seq('AGCTTCAGTCAG', IUPACAmbiguousDNA())
>>>ここで、complement（）メソッドを使用すると、DNAまたはRNAシーケンスを補完できます。 reverse_complement（）メソッドは、結果のシーケンスを左から右に補完および反転します。 以下に示されています-
>>> nucleotide.reverse_complement()
Seq('GACTGACTTCGA', IUPACAmbiguousDNA())Biopythonは、Bio.Data.IUPACDataが提供するambiguous_dna_complement変数を使用して補数演算を実行します。
>>> 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コンテンツ
ゲノムDNAの塩基組成（GCコンテンツ）は、ゲノムの機能と種の生態に大きな影響を与えると予測されています。 GC含有量は、GCヌクレオチドの数を全ヌクレオチドで割ったものです。
GCヌクレオチドの内容を取得するには、次のモジュールをインポートし、次の手順を実行します-
>>> from Bio.SeqUtils import GC
>>> nucleotide = Seq("GACTGACTTCGA",IUPAC.unambiguous_dna)
>>> GC(nucleotide)
50.0転写
転写は、DNA配列をRNA配列に変換するプロセスです。 実際の生物学的転写プロセスでは、逆相補（TCAG→CUGA）を実行して、DNAをテンプレート鎖とみなしてmRNAを取得しています。 ただし、バイオインフォマティクスなどのBiopythonでは、通常、コーディングストランドを直接操作し、文字TをUに変更することでmRNA配列を取得できます。
上記の簡単な例は次のとおりです-
>>> 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())
>>>転写を逆にするには、以下のコードに示すように、TがUに変更されます-
>>> rna_seq = transcribe(dna_seq)
>>> rna_seq.back_transcribe()
Seq('ATGCCGATCGTAT', IUPACUnambiguousDNA())DNAテンプレート鎖を取得するには、以下のように逆転写されたRNAを逆相補します-
>>> rna_seq.back_transcribe().reverse_complement()
Seq('ATACGATCGGCAT', IUPACUnambiguousDNA())翻訳
翻訳は、RNA配列をタンパク質配列に翻訳するプロセスです。 以下に示すようにRNA配列を検討してください-
>>> rna_seq = Seq("AUGGCCAUUGUAAU",IUPAC.unambiguous_rna)
>>> rna_seq
Seq('AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAUAG', IUPACUnambiguousRNA())今、上記のコードにtranslate（）関数を適用します-
>>> rna_seq.translate()
Seq('MAIV', IUPACProtein())上記のRNA配列は単純です。 RNAシーケンス、AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGAを考慮し、translate（）を適用します-
>>> rna = Seq('AUGGCCAUUGUAAUGGGCCGCUGAAAGGGUGCCCGA', IUPAC.unambiguous_rna)
>>> rna.translate()
Seq('MAIVMGR*KGAR', HasStopCodon(IUPACProtein(), '*'))ここでは、停止コドンはアスタリスク「*」で示されています。
translate（）メソッドでは、最初の停止コドンで停止することができます。 これを実行するには、translate（）でto_stop = Trueを次のように割り当てることができます-
>>> rna.translate(to_stop = True)
Seq('MAIVMGR', IUPACProtein())ここでは、終止コドンは含まれていないため、結果の配列には含まれていません。
変換テーブル
NCBIの「遺伝コード」ページには、Biopythonで使用される変換テーブルの完全なリストがあります。 コードを視覚化するための標準的なテーブルの例を見てみましょう-
>>> 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はこの表を使用してDNAをタンパク質に変換し、停止コドンを見つけます。
Biopython-シーケンスI/O操作
Biopythonは、ファイル（任意のストリーム）に対してシーケンスを読み書きするためのモジュールBio.SeqIOを提供します。 バイオインフォマティクスで利用可能なほぼすべてのファイル形式をサポートしています。 ほとんどのソフトウェアは、ファイル形式ごとに異なるアプローチを提供します。 しかし、Biopythonは、SeqRecordオブジェクトを介して、解析されたシーケンスデータをユーザーに提示するために、意識的に単一のアプローチに従います。
次のセクションでSeqRecordの詳細を学びましょう。
SeqRecord
Bio.SeqRecordモジュールは、シーケンスのメタ情報とシーケンスデータ自体を以下に示すように保持するSeqRecordを提供します-
- seq-これは実際のシーケンスです。
- id-これは、指定されたシーケンスのプライマリ識別子です。 デフォルトのタイプは文字列です。
- name-それはシーケンスの名前です。 デフォルトのタイプは文字列です。
- description-シーケンスに関する人間が読める情報を表示します。
- annotations-シーケンスに関する追加情報の辞書です。
SeqRecordは、以下に指定されているようにインポートできます。
from Bio.SeqRecord import SeqRecordこれからのセクションで実際のシーケンスファイルを使用してシーケンスファイルを解析することの微妙な違いを理解しましょう。
シーケンスファイル形式の解析
このセクションでは、最も一般的な2つのシーケンスファイル形式 FASTA および GenBank を解析する方法について説明します。
ファスタ
*FASTA* は、シーケンスデータを保存するための最も基本的なファイル形式です。 もともと、FASTAは、バイオインフォマティクスの初期の進化の間に開発され、主に配列の類似性を検索するために開発された、DNAとタンパク質の配列アライメント用のソフトウェアパッケージです。BiopythonはサンプルのFASTAファイルを提供し、https://github.com/biopython/biopython/blob/master/Doc/examples/ls_orchid.fasta [[[1]] master/Doc/examples/ls_orchid.fasta。]
このファイルをダウンロードし、Biopythonサンプルディレクトリに「orchid.fasta」*として保存します。
Bio.SeqIOモジュールは、シーケンスファイルを処理するparse（）メソッドを提供し、次のようにインポートできます-
from Bio.SeqIO import parseparse（）メソッドには2つの引数が含まれます。1つ目はファイルハンドル、2つ目はファイル形式です。
>>> 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
>>>ここで、parse（）メソッドは、反復ごとにSeqRecordを返す反復可能なオブジェクトを返します。 反復可能であるため、多くの洗練された簡単な方法を提供し、いくつかの機能を見てみましょう。
次（）
_next（）_メソッドは、反復可能なオブジェクトで使用可能な次のアイテムを返します。これを使用して、以下に示す最初のシーケンスを取得できます-
>>> 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
{}
>>>ここでは、FASTA形式はシーケンス注釈をサポートしていないため、seq_record.annotationsは空です。
リスト理解
以下のリスト内包表記を使用して、反復可能なオブジェクトをリストに変換できます。
>>> 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
>>>ここでは、lenメソッドを使用して合計カウントを取得しました。 次のように最大長のシーケンスを取得できます-
>>> 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
>>>以下のコードを使用してシーケンスをフィルタリングすることもできます-
>>> 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
>>>SqlRecordオブジェクト（解析済みデータ）のコレクションをファイルに書き込むことは、以下のようにSeqIO.writeメソッドを呼び出すのと同じくらい簡単です-
file = open("converted.fasta", "w)
SeqIO.write(seq_record, file, "fasta")このメソッドは、以下に指定されている形式を変換するために効果的に使用することができます-
file = open("converted.gbk", "w)
SeqIO.write(seq_record, file, "genbank")GenBank
これは、遺伝子のより豊富なシーケンス形式であり、さまざまな種類の注釈のフィールドが含まれています。 BiopythonはサンプルのGenBankファイルを提供し、https://github.com/biopython/biopython/blob/master/Doc/examples/ls_orchid.fasta [[[2]] master/Doc/examples/ls_orchid.fasta。]
*'orchid.gbk'* としてBiopythonサンプルディレクトリにファイルをダウンロードして保存します以来、Biopythonは単一の関数parseを提供して、すべてのバイオインフォマティクス形式を解析します。 GenBank形式の解析は、parseメソッドの形式オプションを変更するのと同じくらい簡単です。
同じためのコードは以下に与えられています-
>>> 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', ...)
]
}Biopython-配列アライメント
- 配列アラインメント*は、2つ以上の配列（DNA、RNAまたはタンパク質配列）を特定の順序で配列して、それらの間の類似領域を識別するプロセスです。
同様の領域を特定することで、種間で保存されている特性、遺伝的に異なる種の近さ、種の進化方法などの多くの情報を推測できます。 Biopythonは、配列アライメントの広範なサポートを提供します。
この章でBiopythonが提供する重要な機能のいくつかを学びましょう-
解析シーケンスのアライメント
Biopythonは、配列アライメントを読み書きするためのモジュールBio.AlignIOを提供します。 バイオインフォマティクスでは、以前に学習したシーケンスデータと同様に、シーケンスアラインメントデータを指定するために利用できる多くの形式があります。 Bio.AlignIOは、Bio.SeqIOがシーケンスデータで動作し、Bio.AlignIOがシーケンスアラインメントデータで動作することを除いて、Bio.SeqIOと同様のAPIを提供します。
学習を開始する前に、インターネットからサンプルの配列アライメントファイルをダウンロードしてみましょう。
サンプルファイルをダウンロードするには、以下の手順に従ってください-
- ステップ1 *-お気に入りのブラウザを開き、http：//pfam.xfam.org/family/browse Webサイトにアクセスします。 すべてのPfamファミリがアルファベット順に表示されます。
- ステップ2 *-シード値の数が少ないファミリを1つ選択します。 最小限のデータが含まれており、アライメントを簡単に操作できます。 ここで、PF18225を選択/クリックすると、http：//pfam.xfam.org/family/PF18225に移動して、配列アライメントなどの詳細が表示されます。
- ステップ3 *-アラインメントセクションに移動し、ストックホルム形式のシーケンスアラインメントファイル（PF18225_seed.txt）をダウンロードします。
以下のようにBio.AlignIOを使用して、ダウンロードした配列アライメントファイルを読み取ってみましょう-
Bio.AlignIOモジュールのインポート
>>> from Bio import AlignIO読み取りメソッドを使用した読み取りアライメント。 readメソッドは、指定されたファイルで使用可能な単一のアライメントデータを読み取るために使用されます。 指定されたファイルに多くのアライメントが含まれている場合、解析メソッドを使用できます。 parseメソッドは、Bio.SeqIOモジュールのparseメソッドと同様の反復可能なアライメントオブジェクトを返します。
>>> alignment = AlignIO.read(open("PF18225_seed.txt"), "stockholm")整列オブジェクトを印刷します。
>>> 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
>>>また、配列だけでなく、以下で利用可能なシーケンス（SeqRecord）を確認することができます-
>>> for align in alignment:
... print(align.seq)
...
MQNTPAERLPAIIEKAKSKHDINVWLLDRQGRDLLEQRVPAKVATVANQLRGRKRRAFARHREGP
AKQRGIAGLEEWLHRLDHSEAIPIFLIDEAGKDLLEREVPADITA---RLDRRREHGEHGVRKKP
ARRHGQEYFQQWLERQPKKVKEQVFAVDQFGRELLGRPLPEDMAPMLIALNYRNRESHAQVDKKP
TRRHGPESFRFWLERQPVEARDRIYAIDRSGAEILDRPIPRGMAPLFKVLSFRNREDQGLVNNKP
AINRNTQQLTQDLRAMPNWSLRFVYIVDRNNQDLLKRPLPPGIMVLAPRLTAKHPYDKVQDRNRK
AVNATEREFTERIRTLPHWARRNVFVLDSQGFEIFDRELPSPVADLMRKLDLDRPFKKLERKNRT
>>>複数の配置
一般に、ほとんどの配列アライメントファイルには単一のアライメントデータが含まれており、 read メソッドを使用して解析するだけで十分です。 マルチシーケンスアラインメントの概念では、2つ以上のシーケンスが比較され、それらの間のサブシーケンスの最適な一致が得られ、単一ファイルで複数のシーケンスアラインメントが行われます。
入力配列アライメント形式に複数の配列アライメントが含まれている場合、以下に指定されているように*読み取り*メソッドの代わりに*解析*メソッドを使用する必要があります-
>>> 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
>>>ここで、parseメソッドは反復可能なアライメントオブジェクトを返し、実際のアライメントを取得するために反復できます。
ペアワイズ配列アライメント
ペアごとの配列アライメント*は、一度に2つの配列のみを比較し、可能な限り最良の配列アライメントを提供します。 *Pairwise は理解しやすく、結果として生じる配列アライメントから推測するのに例外的です。
Biopythonには、ペアワイズ法を使用してアライメントシーケンスを識別するための特別なモジュール Bio.pairwise2 が用意されています。 Biopythonは、アライメントシーケンスを見つけるために最適なアルゴリズムを適用し、他のソフトウェアと同等です。
ペアワイズモジュールを使用して、2つの単純で仮説的なシーケンスのシーケンスアラインメントを見つける例を作成しましょう。 これは、配列アライメントの概念と、Biopythonを使用してプログラムする方法を理解するのに役立ちます。
ステップ1
以下のコマンドでモジュール pairwise2 をインポートします-
>>> from Bio import pairwise2ステップ2
2つのシーケンス、seq1とseq2を作成します-
>>> from Bio.Seq import Seq
>>> seq1 = Seq("ACCGGT")
>>> seq2 = Seq("ACGT")ステップ3
seq1およびseq2とともにメソッドpairwise2.align.globalxxを呼び出して、以下のコード行を使用してアライメントを見つけます-
>>> alignments = pairwise2.align.globalxx(seq1, seq2)ここで、 globalxx メソッドは実際の作業を実行し、指定されたシーケンスで可能な限り最良のアライメントを見つけます。 実際、Bio.pairwise2は、さまざまなシナリオでアライメントを見つけるために、以下の規則に従う一連のメソッドを提供します。
<sequence alignment type>XYここで、シーケンスアライメントタイプとは、global_または_localのアライメントタイプを指します。 global typeは、シーケンス全体を考慮してシーケンスのアライメントを検出しています。 ローカルタイプは、指定されたシーケンスのサブセットも調べて、シーケンスのアライメントを検出します。 これは面倒ですが、指定されたシーケンス間の類似性についてのより良いアイデアを提供します。
- Xは一致スコアを指します。 可能な値は、x（完全一致）、m（同一の文字に基づくスコア）、d（文字と一致スコアを備えたユーザー提供辞書）、最後にc（カスタムスコアリングアルゴリズムを提供するユーザー定義関数）です。
- Yはギャップペナルティを表します。 可能な値は、x（ギャップペナルティなし）、s（両方のシーケンスに同じペナルティ）、d（各シーケンスに異なるペナルティ）、最後にc（カスタムギャップペナルティを提供するユーザー定義関数）です。
したがって、localdsも有効なメソッドであり、ローカルアライメント手法、一致用のユーザー指定辞書、および両方のシーケンスのユーザー指定ギャップペナルティを使用してシーケンスのアライメントを検索します。
>>> test_alignments = pairwise2.align.localds(seq1, seq2, blosum62, -10, -1)ここで、blosum62は、一致スコアを提供するためにpairwise2モジュールで使用可能な辞書を指します。 -10はギャップオープンペナルティを示し、-1はギャップ拡張ペナルティを示します。
ステップ4
反復可能な整列オブジェクトをループし、個々の整列オブジェクトを取得して印刷します。
>>> 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)ステップ5
Bio.pairwise2モジュールは、フォーマットメソッド、format_alignmentを提供して、結果をよりよく視覚化します-
>>> 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には、配列アライメントを行うための別のモジュールAlignもあります。 このモジュールは、アルゴリズム、モード、マッチスコア、ギャップペナルティなどのパラメータの設定だけに異なるAPIセットを提供します。Alignオブジェクトの簡単な外観は次のとおりです-
>>> 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
>>>配列アライメントツールのサポート
Biopythonは、Bio.Align.Applicationsモジュールを介して多くの配列アライメントツールへのインターフェイスを提供します。 ツールの一部を以下に示します-
- ClustalW
- 筋
- エンボス針と水
最も一般的なアライメントツールClustalWを使用して、配列アライメントを作成するBiopythonの簡単な例を作成しましょう。
- ステップ1 *-Clustalwプログラムをhttp://www.clustal.org/download/current/からダウンロードしてインストールします。 また、システムパスを「clustal」インストールパスで更新します。
- ステップ2 *-モジュールBio.Align.ApplicationsからClustalwCommanLineをインポートします。
>>> from Bio.Align.Applications import ClustalwCommandline- ステップ3 *-入力ファイル、Biopythonパッケージで利用可能なopuntia.fastaでClustalwCommanLineを呼び出してcmdを設定します。 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.fasta- ステップ4 *-cmd（）を呼び出すと、clustalwコマンドが実行され、結果のアライメントファイルopuntia.alnの出力が提供されます。
>>> stdout, stderr = cmd()- ステップ5 *-以下のようにアライメントファイルを読み取り、印刷します-
>>> 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
>>>Biopython-BLASTの概要
BLASTは、 Basic Local Alignment Search Tool の略です。 生物学的配列間の類似領域を見つけます。 Biopythonは、NCBI BLAST操作を処理するBio.Blastモジュールを提供します。 BLASTは、ローカル接続またはインターネット接続で実行できます。
次のセクションでこれらの2つの接続を簡単に理解しましょう-
インターネット経由で実行する
Biopythonは、BLASTのオンラインバージョンを呼び出すBio.Blast.NCBIWWWモジュールを提供します。 これを行うには、次のモジュールをインポートする必要があります-
>>> from Bio.Blast import NCBIWWWNCBIWWモジュールは、BLASTオンラインバージョンhttps://blast.ncbi.nlm.nih.gov/Blast.cgiを照会するqblast関数を提供します。 qblastは、オンラインバージョンでサポートされているすべてのパラメーターをサポートしています。
このモジュールに関するヘルプを取得するには、以下のコマンドを使用し、機能を理解します-
>>> 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/apil).
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/apil通常、qblast関数の引数は、BLAST Webページで設定できるさまざまなパラメーターに基本的に類似しています。 これにより、qblast関数の理解が容易になり、使用するための学習曲線が縮小されます。
接続と検索
BLASTオンラインバージョンの接続と検索のプロセスを理解するために、Biopythonを介してオンラインBLASTサーバーに対して単純なシーケンス検索（ローカルシーケンスファイルで利用可能）を行いましょう。
ステップ1 *-Biopythonディレクトリに *blast_example.fasta という名前のファイルを作成し、入力として以下のシーケンス情報を提供します
Example of a single sequence in FASTA/Pearson format:
>sequence A ggtaagtcctctagtacaaacacccccaatattgtgatataattaaaattatattcatat
tctgttgccagaaaaaacacttttaggctatattagagccatcttctttgaagcgttgtc
>sequence B ggtaagtcctctagtacaaacacccccaatattgtgatataattaaaattatattca
tattctgttgccagaaaaaacacttttaggctatattagagccatcttctttgaagcgttgtc- ステップ2 *-NCBIWWWモジュールをインポートします。
>>> from Bio.Blast import NCBIWWWステップ3 *-python IOモジュールを使用して、シーケンスファイル *blast_example.fasta を開きます。
>>> 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'- ステップ4 *-ここで、メインデータとしてシーケンスデータを渡すqblast関数を呼び出します。 もう1つのパラメーターは、データベース（nt）と内部プログラム（blastn）を表します。
>>> result_handle = NCBIWWW.qblast("blastn", "nt", sequence_data)
>>> result_handle
<_io.StringIO object at 0x000001EC9FAA4558>*blast_results* は検索結果を保持します。 後で使用するためにファイルに保存したり、解析して詳細を取得したりできます。 次のセクションでその方法を学習します。- ステップ5 *-以下に示すように、fastaファイル全体を使用するのではなく、Seqオブジェクトを使用しても同じ機能を実行できます-
>>> 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())ここで、メインパラメータとしてSeqオブジェクトであるrecord.seqを渡すqblast関数を呼び出します。
>>> result_handle = NCBIWWW.qblast("blastn", "nt", seq_record.seq)
>>> print(result_handle)
<_io.StringIO object at 0x000001EC9FAA4558>BLASTは、シーケンスに識別子を自動的に割り当てます。
- ステップ6 *-result_handleオブジェクトには結果全体が含まれ、後で使用するためにファイルに保存できます。
>>> with open('results.xml', 'w') as save_file:
>>> blast_results = result_handle.read()
>>> save_file.write(blast_results)結果ファイルの解析方法については、後のセクションで説明します。
スタンドアロンBLASTの実行
このセクションでは、ローカルシステムでBLASTを実行する方法について説明します。 ローカルシステムでBLASTを実行すると、高速になり、独自のデータベースを作成してシーケンスを検索することもできます。
BLASTの接続
一般に、BLASTをローカルで実行することは、サイズが大きく、ソフトウェアを実行するために余分な労力が必要で、コストがかかるため、お勧めしません。 オンラインBLASTは、基本的および高度な目的には十分です。 もちろん、ローカルにインストールする必要がある場合があります。
多くの時間と大量のネットワークを必要とするオンラインで頻繁に検索を行っていることを考慮してください。独自のシーケンスデータまたはIP関連の問題がある場合は、ローカルにインストールすることをお勧めします。
これを行うには、以下の手順に従う必要があります-
- ステップ1 *-指定されたリンクを使用して最新のブラストバイナリをダウンロードしてインストールします-ftp://ftp.ncbi.nlm.nih.gov/blast/executables/blast+/LATEST/
- ステップ2 *-以下のリンクを使用して、最新の必要なデータベースをダウンロードして解凍します-ftp://ftp.ncbi.nlm.nih.gov/blast/db/
BLASTソフトウェアは、サイトに多くのデータベースを提供します。 ブラストデータベースサイトからftp://ftp.ncbi.nlm.nih.gov/blast/db/FASTA/alu.n.gz[alu.n.gz]ファイルをダウンロードし、aluフォルダーに解凍します。 このファイルはFASTA形式です。 ブラストアプリケーションでこのファイルを使用するには、まずファイルをFASTA形式からブラストデータベース形式に変換する必要があります。 BLASTは、この変換を行うmakeblastdbアプリケーションを提供します。
以下のコードスニペットを使用してください-
cd/path/to/alu
makeblastdb -in alu.n -parse_seqids -dbtype nucl -out alun上記のコードを実行すると、入力ファイルalu.nが解析され、複数のファイルalun.nsq、alun.nsiなどとしてBLASTデータベースが作成されます。 これで、このデータベースにクエリを実行してシーケンスを見つけることができます。
ローカルサーバーにBLASTをインストールし、サンプルのBLASTデータベース、 alun を照会します。
- ステップ3 *-データベースを照会するサンプルシーケンスファイルを作成しましょう。 ファイルsearch.fsaを作成し、以下のデータをそこに入れます。
>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
AGシーケンスデータはalu.nファイルから収集されます。したがって、データベースと一致します。
ステップ4 *-BLASTソフトウェアは、データベースを検索するための多くのアプリケーションを提供し、blastnを使用します。 *blastnアプリケーションには、db、query、outの少なくとも3つの引数が必要です。 db は、検索対象のデータベースを指します。 query は一致するシーケンスで、 out は結果を保存するファイルです。 今、この単純なクエリを実行するために以下のコマンドを実行します-
blastn -db alun -query search.fsa -out results.xml -outfmt 5上記のコマンドを実行すると、以下に示すように results.xml ファイルで検索され、出力が得られます（部分的にデータ）
<?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>上記のコマンドは、以下のコードを使用してPython内で実行できます-
>>> from Bio.Blast.Applications import NcbiblastnCommandline
>>> blastn_cline = NcbiblastnCommandline(query = "search.fasta", db = "alun",
outfmt = 5, out = "results.xml")
>>> stdout, stderr = blastn_cline()ここで、最初のものは爆風出力へのハンドルであり、2番目は爆風コマンドによって生成される可能性のあるエラー出力です。
出力ファイルをコマンドライン引数（out =“ results.xml”）として提供し、出力形式をXML（outfmt = 5）として設定しているため、出力ファイルは現在の作業ディレクトリに保存されます。
BLAST結果の解析
一般に、BLAST出力はNCBIXMLモジュールを使用してXML形式として解析されます。 これを行うには、次のモジュールをインポートする必要があります-
>>> from Bio.Blast import NCBIXMLここで、 Python open method を使用してファイルを直接開き、以下に示すように use NCBIXML parse method を使用します-
>>> 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])これにより、次のような出力が生成されます-
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)Biopython-Entrezデータベース
*Entrez* は、NCBIが提供するオンライン検索システムです。 ブール演算子とフィールド検索をサポートする統合グローバルクエリを使用して、ほぼすべての既知の分子生物学データベースへのアクセスを提供します。 各データベースからのヒット数、発信元データベースへのリンクを持つレコードなどの情報を含むすべてのデータベースから結果を返します。Entrezを介してアクセスできる一般的なデータベースの一部を以下に示します-
- パブメッド
- パブメッドセントラル
- ヌクレオチド（GenBank配列データベース）
- タンパク質（配列データベース）
- ゲノム（全ゲノムデータベース）
- 構造（三次元高分子構造）
- 分類（GenBankの生物）
- SNP（一塩基多型）
- UniGene（転写配列の遺伝子指向クラスター）
- CDD（保存タンパク質ドメインデータベース）
- 3Dドメイン（Entrez構造からのドメイン）
上記のデータベースに加えて、Entrezはフィールド検索を実行するためにより多くのデータベースを提供します。
Biopythonは、EntrezデータベースにアクセスするためのEntrez固有のモジュールBio.Entrezを提供します。 この章では、Biopythonを使用してEntrezにアクセスする方法を学びましょう-
データベース接続手順
Entrezの機能を追加するには、次のモジュールをインポートします-
>>> from Bio import Entrez次に、以下のコードで誰が接続されているかを特定するためにメールを設定します-
>>> Entrez.email = '<youremail>'次に、Entrezツールパラメーターを設定します。デフォルトでは、Biopythonです。
>>> Entrez.tool = 'Demoscript'ここで、以下に定義されているように、各データベースのインデックス用語カウント、最終更新、および利用可能なリンクを見つけるために* einfo関数を呼び出します-
>>> info = Entrez.einfo()einfoメソッドは、以下に示すように、その読み取りメソッドを介して情報へのアクセスを提供するオブジェクトを返します-
>>> 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>データはXML形式であり、Pythonオブジェクトとしてデータを取得するには、* Entrez.einfo（）メソッドが呼び出されたらすぐに *Entrez.read メソッドを使用します-
>>> info = Entrez.einfo()
>>> record = Entrez.read(info)ここで、レコードは、以下に示すように、1つのキー、DbListを持つ辞書です-
>>> record.keys()
[u'DbList']DbListキーにアクセスすると、以下に示すデータベース名のリストが返されます-
>>> 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']
>>>基本的に、EntrezモジュールはEntrez検索システムから返されたXMLを解析し、Python辞書とリストとして提供します。
検索データベース
Entrezデータベースのいずれかを検索するには、Bio.Entrez.esearch（）モジュールを使用できます。 以下に定義されています-
>>> 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 = {})
>>>間違ったdbを割り当てると、それは戻ります
>>> 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 = {})データベース全体を検索する場合は、 Entrez.egquery を使用できます。 これは Entrez.esearch と似ていますが、キーワードを指定してデータベースパラメータをスキップするだけで十分です。
>>>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 0レコードを取得する
Enterzは、Entrezからレコードの完全な詳細を検索およびダウンロードするための特別な方法であるefetchを提供します。 次の簡単な例を検討してください-
>>> handle = Entrez.efetch(
db = "nucleotide", id = "EU490707", rettype = "fasta")これで、SeqIOオブジェクトを使用して簡単にレコードを読み取ることができます
>>> 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-PDBモジュール
Biopythonは、ポリペプチド構造を操作するBio.PDBモジュールを提供します。 PDB（Protein Data Bank）は、オンラインで入手可能な最大のタンパク質構造リソースです。 タンパク質-タンパク質、タンパク質-DNA、タンパク質-RNA複合体など、多くの異なるタンパク質構造をホストします。
PDBをロードするには、以下のコマンドを入力します-
from Bio.PDB import *タンパク質構造ファイル形式
PDBは3つの異なる形式でタンパク質構造を配布します-
- BiopythonでサポートされていないXMLベースのファイル形式
- 特別にフォーマットされたテキストファイルであるpdbファイル形式
- PDBx/mmCIFファイル形式
Protein Data Bankによって配布されたPDBファイルには、フォーマットエラーが含まれている可能性があり、そのために曖昧になったり、解析が難しくなったりします。 Bio.PDBモジュールは、これらのエラーを自動的に処理しようとします。
Bio.PDBモジュールは2つの異なるパーサーを実装します。1つはmmCIF形式で、もう1つはpdb形式です。
各形式を詳細に解析する方法を学びましょう-
mmCIFパーサー
以下のコマンドを使用して、PDBサーバーからmmCIF形式のサンプルデータベースをダウンロードしましょう-
>>> pdbl = PDBList()
>>> pdbl.retrieve_pdb_file('2FAT', pdir = '.', file_format = 'mmCif')これにより、指定されたファイル（2fat.cif）がサーバーからダウンロードされ、現在の作業ディレクトリに保存されます。
ここで、PDBListは、オンラインPDB FTPサーバーからファイルをリストおよびダウンロードするオプションを提供します。 retrieve_pdb_fileメソッドには、拡張子なしでダウンロードするファイルの名前が必要です。 retrieve_pdb_fileには、ダウンロードディレクトリ、pdir、およびファイルの形式file_formatを指定するオプションもあります。 ファイル形式の可能な値は次のとおりです-
- 「mmCif」（デフォルト、PDBx/mmCifファイル）
- “ pdb”（フォーマットPDB）
- 「xml」（PMDML/XML形式）
- 「mmtf」（高圧縮） *「バンドル」（大規模構造のPDB形式のアーカイブ）
CIFファイルをロードするには、以下に指定されているようにBio.MMCIF.MMCIFParserを使用します-
>>> parser = MMCIFParser(QUIET = True)
>>> data = parser.get_structure("2FAT", "2FAT.cif")ここでは、QUIETはファイルの解析中に警告を抑制します。* get_structureはファイルを解析し、2FAT *（最初の引数）としてidを持つ構造を返します。
上記のコマンドを実行した後、ファイルを解析し、可能な場合は警告を出力します。
今、以下のコマンドを使用して構造を確認します-
>>> data
<Structure id = 2FAT>
To get the type, use type method as specified below,
>>> print(type(data))
<class 'Bio.PDB.Structure.Structure'>ファイルの解析に成功し、タンパク質の構造を取得しました。 タンパク質構造の詳細と取得方法については、後の章で説明します。
PDBパーサー
以下のコマンドを使用して、PDBサーバーからPDB形式のサンプルデータベースをダウンロードしましょう-
>>> pdbl = PDBList()
>>> pdbl.retrieve_pdb_file('2FAT', pdir = '.', file_format = 'pdb')これにより、指定したファイル（pdb2fat.ent）がサーバーからダウンロードされ、現在の作業ディレクトリに保存されます。
pdbファイルをロードするには、以下に指定されているようにBio.PDB.PDBParserを使用します-
>>> parser = PDBParser(PERMISSIVE = True, QUIET = True)
>>> data = parser.get_structure("2fat","pdb2fat.ent")ここで、get_structureはMMCIFParserに似ています。 PERMISSIVEオプションは、タンパク質データを可能な限り柔軟に解析しようとします。
次に、以下に示すコードスニペットで構造とそのタイプを確認します-
>>> data
<Structure id = 2fat>
>>> print(type(data))
<class 'Bio.PDB.Structure.Structure'>さて、ヘッダー構造には辞書情報が格納されています。 これを実行するには、以下のコマンドを入力します-
>>> print(data.header.keys()) dict_keys([
'name', 'head', 'deposition_date', 'release_date', 'structure_method', 'resolution',
'structure_reference', 'journal_reference', 'author', 'compound', 'source',
'keywords', 'journal'])
>>>名前を取得するには、次のコードを使用します-
>>> print(data.header["name"])
an anti-urokinase plasminogen activator receptor (upar) antibody: crystal
structure and binding epitope
>>>また、以下のコードで日付と解像度を確認することができます-
>>> print(data.header["release_date"]) 2006-11-14
>>> print(data.header["resolution"]) 1.77PDB構造
PDB構造は、2つのチェーンを含む単一のモデルで構成されます。
- 残基数を含むチェーンL
- 残基数を含むチェーンH
各残基は複数の原子で構成され、各原子は（x、y、z）座標で表される3D位置を持ちます。
以下のセクションで原子の構造を詳細に取得する方法を学びましょう-
モデル
Structure.get_models（）メソッドは、モデルの反復子を返します。 以下に定義されています-
>>> 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'>ここで、モデルは正確に1つの3D立体配座を表します。 1つ以上のチェーンが含まれています。
鎖
Model.get_chain（）メソッドは、チェーンの反復子を返します。 以下に定義されています-
>>> chains = list(models[0].get_chains())
>>> chains
[<Chain id = L>, <Chain id = H>]
>>> type(chains[0])
<class 'Bio.PDB.Chain.Chain'>ここで、Chainは適切なポリペプチド構造、つまり、結合した残基の連続した配列を表します。
残基
Chain.get_residues（）メソッドは、残基の反復子を返します。 以下に定義されています-
>>> residue = list(chains[0].get_residues())
>>> len(residue)
293
>>> residue1 = list(chains[1].get_residues())
>>> len(residue1)
311さて、Residueはアミノ酸に属する原子を保持しています。
原子
Residue.get_atom（）は、以下で定義されているように、原子の反復子を返します-
>>> atoms = list(residue[0].get_atoms())
>>> atoms
[<Atom N>, <Atom CA>, <Atom C>, <Atom Ov, <Atom CB>, <Atom CG>, <Atom OD1>, <Atom OD2>]アトムは、アトムの3D座標を保持し、ベクターと呼ばれます。 以下に定義されています
>>> atoms[0].get_vector()
<Vector 18.49, 73.26, 44.16>x、y、z座標値を表します。
Biopython-Motifオブジェクト
配列モチーフは、ヌクレオチドまたはアミノ酸の配列パターンです。 配列モチーフは、隣接していない可能性のあるアミノ酸の三次元配列によって形成されます。 Biopythonは、以下に指定されているように、配列モチーフの機能にアクセスするための独立したモジュールBio.motifsを提供します-
from Bio import motifs単純なDNAモチーフの作成
以下のコマンドを使用して簡単なDNAモチーフ配列を作成しましょう-
>>> 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 AACTシーケンス値をカウントするには、以下のコマンドを使用します-
>>> 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.00次のコードを使用して、シーケンス内の「A」をカウントします-
>>> seq.counts["A", :]
(2, 1, 0, 1)あなたがカウントの列にアクセスしたい場合は、以下のコマンドを使用します-
>>> seq.counts[:, 3]
{'A': 1, 'C': 0, 'T': 2, 'G': 0}シーケンスロゴの作成
次に、シーケンスロゴの作成方法について説明します。
以下のシーケンスを考慮してください-
AGCTTACG
ATCGTACC
TTCCGAAT
GGTACGTA
AAGCTTGG次のリンクを使用して独自のロゴを作成できます-http://weblogo.berkeley.edu/
上記のシーケンスを追加して新しいロゴを作成し、seq.pngという名前の画像をbiopythonフォルダーに保存します。
seq.pngイメージを作成した後、次のコマンドを実行します-
>>> seq.weblogo("seq.png")このDNA配列モチーフは、LexA結合モチーフの配列ロゴとして表されます。
JASPARデータベース
JASPARは最も人気のあるデータベースの1つです。 シーケンスの読み取り、書き込み、スキャンのためのモチーフ形式のいずれかの機能を提供します。 各モチーフのメタ情報を保存します。 モジュールBio.motifsには、メタ情報の属性を表す特別なクラスjaspar.Motifが含まれています。
次の注目すべき属性タイプがあります-
- matrix_id-一意のJASPARモチーフID
- name-モチーフの名前
- tf_family-モチーフのファミリー、例えば 「ヘリックス-ループ-ヘリックス」
- data_type-モチーフで使用されるデータのタイプ。
biopythonフォルダーのsample.sitesにあるJASPARサイト形式を作成しましょう。 以下に定義されています-
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
cggcctCGCGTGc上記のファイルでは、モチーフインスタンスを作成しました。 さて、上記のインスタンスからモチーフオブジェクトを作成しましょう-
>>> 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.00ここで、データは、sample.sitesファイルからすべてのモチーフインスタンスを読み取ります。
データからすべてのインスタンスを印刷するには、以下のコマンドを使用します-
>>> for instance in data.instances:
... print(instance)
...
AACGTG
CAGGTG
TACGTA
AACGTG
CACGTG
CGCGTG以下のコマンドを使用して、すべての値をカウントします-
>>> 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
>>>Biopython-BioSQLモジュール
*BioSQL* は、すべてのRDBMSエンジンのシーケンスとその関連データを格納するために主に設計された汎用データベーススキーマです。 GenBank、Swissportなどの一般的なすべてのバイオインフォマティクスデータベースからのデータを保持するように設計されています。 社内データの保存にも使用できます。*BioSQL* は現在、以下のデータベースに特定のスキーマを提供しています-- MySQL（biosqldb-mysql.sql）
- PostgreSQL（biosqldb-pg.sql） Oracle（biosqldb-ora/ 。sql） *SQLite（biosqldb-sqlite.sql）
また、JavaベースのHSQLDBおよびDerbyデータベースの最小限のサポートも提供します。
BioPythonは、BioSQLベースのデータベースを操作するための非常にシンプルで簡単で高度なORM機能を提供します。* BioPythonは、次の機能を実行するモジュールBioSQL *を提供します-
- BioSQLデータベースを作成/削除する
- BioSQLデータベースに接続する
- GenBank、Swisport、BLAST結果、Entrez結果などのシーケンスデータベースを解析し、BioSQLデータベースに直接ロードします
- BioSQLデータベースからシーケンスデータを取得する
- NCBI BLASTから分類データを取得し、BioSQLデータベースに保存します
- BioSQLデータベースに対してSQLクエリを実行する
BioSQLデータベーススキーマの概要
BioSQLの詳細を説明する前に、BioSQLスキーマの基本を理解しましょう。 BioSQLスキーマは、シーケンスデータ、シーケンス機能、シーケンスカテゴリ/オントロジー、および分類情報を保持する25以上のテーブルを提供します。 重要なテーブルのいくつかは次のとおりです-
- バイオデータベース
- バイオエントリー
- バイオシーケンス
- seqfeature
- 分類群
- taxon_name
- アントロジー
- term
- dxref
BioSQLデータベースの作成
このセクションでは、BioSQLチームが提供するスキーマを使用して、サンプルのBioSQLデータベースbiosqlを作成します。 始めるのは本当に簡単で、複雑な設定がないので、SQLiteデータベースを使用します。
ここでは、以下の手順を使用して、SQLiteベースのBioSQLデータベースを作成します。
- ステップ1 *-SQLiteデータベースエンジンをダウンロードしてインストールします。
- ステップ2 *-GitHub URLからBioSQLプロジェクトをダウンロードします。 https://github.com/biosql/biosql
- ステップ3 *-コンソールを開き、mkdirを使用してディレクトリを作成し、入力します。
cd/path/to/your/biopython/sample
mkdir sqlite-biosql
cd sqlite-biosql- ステップ4 *-以下のコマンドを実行して、新しいSQLiteデータベースを作成します。
> sqlite3.exe mybiosql.db
SQLite version 3.25.2 2018-09-25 19:08:10
Enter ".help" for usage hints.
sqlite>- ステップ5 *-BioSQLプロジェクト（/sql/biosqldb-sqlite.sql`）からbiosqldb-sqlite.sqlファイルをコピーし、現在のディレクトリに保存します。
- ステップ6 *-以下のコマンドを実行して、すべてのテーブルを作成します。
sqlite> .read biosqldb-sqlite.sqlこれで、すべてのテーブルが新しいデータベースに作成されました。
- ステップ7 *-データベース内のすべての新しいテーブルを表示するには、以下のコマンドを実行します。
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>最初の3つのコマンドは、フォーマットされた方法で結果を表示するようにSQLiteを構成する構成コマンドです。
- ステップ8 *-BioGenチームhttps://raw.githubusercontent.com/biopython/biopython/master/Doc/examples/ls_orchid.gbkが提供するサンプルGenBankファイルls_orchid.gbkを現在のディレクトリにコピーし、orchidとして保存します。 .gbk。
- ステップ9 *-以下のコードを使用してpythonスクリプトload_orchid.pyを作成し、実行します。
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()上記のコードは、ファイル内のレコードを解析し、それをpythonオブジェクトに変換し、BioSQLデータベースに挿入します。 後のセクションでコードを分析します。
最後に、新しいBioSQLデータベースを作成し、いくつかのサンプルデータをロードします。 次の章で重要な表について説明します。
シンプルなER図
*biodatabase* テーブルは階層の最上位にあり、その主な目的は、一連のシーケンスデータを単一のグループ/仮想データベースに整理することです。 *バイオデータベース内のすべてのエントリは別のデータベースを参照し、別のデータベースとは混ざりません。* BioSQLデータベース内のすべての関連テーブルには、バイオデータベースエントリへの参照があります。*bioentry* テーブルには、シーケンスデータを除く、シーケンスに関するすべての詳細が保持されます。 特定の *bioentry* の配列データは *biosequence* テーブルに保存されます。taxonおよびtaxon_nameは分類の詳細であり、すべてのエントリはこのテーブルを参照して分類情報を指定します。
スキーマを理解した後、次のセクションでいくつかのクエリを見てみましょう。
BioSQLクエリ
データがどのように構成され、テーブルが互いに関連しているかをよりよく理解するために、いくつかのSQLクエリを掘り下げてみましょう。 先に進む前に、以下のコマンドを使用してデータベースを開き、いくつかの書式設定コマンドを設定しましょう-
> 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と.modeは、データを視覚化するためのフォーマットオプションです*。 また、SQLiteエディターを使用してクエリを実行することもできます。
以下に示すように、システムで使用可能な仮想シーケンスデータベースをリストします-
select
*
from
biodatabase;
** *Result* **
sqlite> .width 15 15 15 15
sqlite> select * from biodatabase;
biodatabase_id name authority description
--------------- --------------- --------------- ---------------
1 orchid
sqlite>ここでは、 _ orchid_ という1つのデータベースのみがあります。
以下のコードを使用して、データベース orchid で使用可能なエントリ（上位3）を一覧表示します
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>エントリに関連付けられているシーケンスの詳細をリストします（アクセッション-Z78530、名前-C。 fasciculatum 5.8S rRNA遺伝子とITS1およびITS2 DNA）指定されたコード-
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>エントリに関連付けられている完全なシーケンスを取得します（アクセッション-Z78530、名前-C。 fasciculatum 5.8S rRNA遺伝子とITS1およびITS2 DNA）以下のコードを使用して-
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>バイオデータベースに関連付けられた分類群のリスト
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>BioSQLデータベースにデータをロードする
この章では、シーケンスデータをBioSQLデータベースに読み込む方法を学びましょう。 前のセクションでデータベースにデータをロードするコードがすでにあり、コードは次のとおりです-
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()私たちはコードのすべての行とその目的をより深く見ていきます-
- 行1 *-SeqIOモジュールをロードします。
- 行2 *-BioSeqDatabaseモジュールをロードします。 このモジュールは、BioSQLデータベースと対話するためのすべての機能を提供します。
- 行3 *-osモジュールをロードします。
- 行5 *-open_databaseは、構成されたドライバー（ドライバー）で指定されたデータベース（db）を開き、BioSQLデータベース（サーバー）にハンドルを返します。 Biopythonは、sqlite、mysql、postgresql、oracleデータベースをサポートしています。
- 行6-10 *-load_database_sqlメソッドは、外部ファイルからsqlをロードして実行します。 commitメソッドはトランザクションをコミットします。 すでにスキーマを使用してデータベースを作成しているため、この手順をスキップできます。
- 行12 *-new_databaseメソッドは、新しい仮想データベースorchidを作成し、蘭データベースに対してコマンドを実行するためのハンドルdbを返します。
- 13行目-loadメソッドは、シーケンスエントリ（反復可能なSeqRecord）をランデータベースにロードします。 SqlIO.parseはGenBankデータベースを解析し、その中のすべてのシーケンスを反復可能なSeqRecordとして返します。 loadメソッドの2番目のパラメーター（True）は、NCBIブラストWebサイトからシーケンスデータの分類の詳細を取得するように指示します（システムでまだ利用できない場合）。
- 行14 *-commitはトランザクションをコミットします。
- 行15 *-closeはデータベース接続を閉じ、サーバーハンドルを破棄します。
シーケンスデータを取得する
以下のように、蘭データベースから識別子2765658でシーケンスをフェッチします-
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))ここで、server ["orchid"]は、仮想databaseorchidからデータを取得するためのハンドルを返します。 lookup メソッドは、基準に基づいてシーケンスを選択するオプションを提供し、識別子2765658を持つシーケンスを選択しました。 lookup は、シーケンス情報をSeqRecordobjectとして返します。 SeqRecordの操作方法はすでにわかっているため、そこからデータを取得するのは簡単です。
データベースを削除する
データベースの削除は、適切なデータベース名でremove_databaseメソッドを呼び出し、次に指定されたとおりにコミットするだけです。
from BioSQL import BioSeqDatabase
server = BioSeqDatabase.open_database(driver = 'sqlite3', db = "orchid.db")
server.remove_database("orchids")
server.commit()Biopython-集団遺伝学
集団遺伝学は進化論において重要な役割を果たします。 種と同じ種内の2人以上の個体間の遺伝的差異を分析します。
Biopythonは人口遺伝学向けのBio.PopGenモジュールを提供し、主に `GenePop、Michel RaymondとFrancois Roussetが開発した人気のある遺伝学パッケージをサポートしています。
シンプルなパーサー
GenePop形式を解析して概念を理解するための簡単なアプリケーションを作成しましょう。
下記のリンクでBiopythonチームが提供するgenePopファイルをダウンロードします-https://raw.githubusercontent.com/biopython/biopython/master/Tests/PopGen/c3line.gen
以下のコードスニペットを使用してGenePopモジュールをロードします-
from Bio.PopGen import GenePop以下のようにGenePop.readメソッドを使用してファイルを解析します-
record = GenePop.read(open("c3line.gen"))以下に示すように、遺伝子座と人口の情報を表示します-
>>> record.loci_list
['136255903', '136257048', '136257636']
>>> record.pop_list
['4', 'b3', '5']
>>> record.populations
[[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)])]]
>>>ここで、ファイルには3つの遺伝子座と3つの母集団があります。最初の母集団には4つのレコード、2番目の母集団には3つのレコード、3番目の母集団には5つのレコードがあります。 record.populationsは、各遺伝子座の対立遺伝子データを持つすべての集団のセットを示します。
GenePopファイルを操作する
Biopythonには、軌跡および個体群データを削除するオプションがあります。
位置によって設定された母集団を削除する
>>> 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)])]]
>>>位置による軌跡の削除、
>>> 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)])]]
>>>名前で軌跡を削除する
>>> 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)])]]
>>>GenePopソフトウェアとのインターフェース
Biopythonは、GenePopソフトウェアとやり取りするためのインターフェイスを提供し、それにより多くの機能を公開します。 Bio.PopGen.GenePopモジュールは、この目的に使用されます。 このような使いやすいインターフェイスの1つがEasyControllerです。 GenePopファイルの解析方法を確認し、EasyControllerを使用して分析を行います。
まず、GenePopソフトウェアをインストールし、インストールフォルダをシステムパスに配置します。 GenePopファイルに関する基本情報を取得するには、EasyControllerオブジェクトを作成し、次に指定されているget_basic_infoメソッドを呼び出します-
>>> from Bio.PopGen.GenePop.EasyController import EasyController
>>> ec = EasyController('c3line.gen')
>>> print(ec.get_basic_info())
(['4', 'b3', '5'], ['136255903', '136257048', '136257636'])
>>>ここで、最初の項目は母集団リストであり、2番目の項目は遺伝子座リストです。
特定の遺伝子座のすべての対立遺伝子リストを取得するには、以下に指定されているように遺伝子座名を渡すことによりget_alleles_all_popsメソッドを呼び出します-
>>> allele_list = ec.get_alleles_all_pops("136255903")
>>> print(allele_list)
[2, 3]特定の母集団と遺伝子座ごとに対立遺伝子リストを取得するには、以下に示すように遺伝子座名と母集団の位置を渡してget_allelesを呼び出します-
>>> 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]
>>>同様に、EasyControllerは多くの機能を公開しています：対立遺伝子頻度、遺伝子型頻度、多遺伝子座F統計、Hardy-Weinberg平衡、連鎖不平衡など。
Biopython-ゲノム解析
ゲノムは、そのすべての遺伝子を含むDNAの完全なセットです。 ゲノム解析とは、個々の遺伝子とその遺伝における役割の研究を指します。
ゲノム図
ゲノム図は、遺伝情報をチャートとして表します。 BiopythonはBio.Graphics.GenomeDiagramモジュールを使用してGenomeDiagramを表します。 GenomeDiagramモジュールには、ReportLabのインストールが必要です。
ダイアグラムを作成する手順
図を作成するプロセスは、一般的に以下の単純なパターンに従います-
- 表示する機能の個別のセットごとにFeatureSetを作成し、Bio.SeqFeatureオブジェクトをそれらに追加します。
- 表示するグラフごとにGraphSetを作成し、グラフデータを追加します。
- ダイアグラム上で必要な各トラックのトラックを作成し、必要なトラックにGraphSetsとFeatureSetsを追加します。
- ダイアグラムを作成し、それにトラックを追加します。
- 画像を描画するようにダイアグラムに指示します。
- 画像をファイルに書き込みます。
入力GenBankファイルの例を見てみましょう-
[[3]] 以下で説明します、
以下に示すように、最初にすべてのモジュールをインポートします-
>>> from reportlab.lib import colors
>>> from reportlab.lib.units import cm
>>> from Bio.Graphics import GenomeDiagram今、データを読み取るためにSeqIOモジュールをインポートします-
>>> from Bio import SeqIO
record = SeqIO.read("example.gb", "genbank")ここでは、レコードはgenbankファイルからシーケンスを読み取ります。
次に、空の図を作成して、トラックと機能セットを追加します-
>>> diagram = GenomeDiagram.Diagram(
"Yersinia pestis biovar Microtus plasmid pPCP1")
>>> track = diagram.new_track(1, name="Annotated Features")
>>> feature = track.new_set()今、私たちは以下に定義されているように緑から灰色への代替色を使用して色のテーマの変更を適用することができます-
>>> 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)これで、画面に以下の応答が表示されます-
<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>上記の入力レコードの図を描きましょう-
>>> 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")上記のコマンドを実行すると、Biopythonディレクトリに次の画像が保存されます。
* *Result* *
genome.pngまた、以下の変更を行うことにより、円形形式で画像を描くことができます-
>>> 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")染色体の概要
DNA分子は、染色体と呼ばれる糸状の構造にパッケージ化されています。 各染色体は、その構造をサポートするヒストンと呼ばれるタンパク質の周りに何度もしっかりとコイル状に巻かれたDNAで構成されています。
細胞が分裂していない場合、染色体は細胞の核では見えません。顕微鏡でも見えません。 ただし、染色体を構成するDNAは細胞分裂中により密に詰まり、顕微鏡で見ることができます。
ヒトでは、各細胞には通常23組の染色体が含まれており、合計46組です。 常染色体と呼ばれるこれらのペアの22は、男性と女性の両方で同じように見えます。 23番目のペアである性染色体は、男性と女性で異なります。 女性はX染色体のコピーを2つ持っていますが、男性はX染色体とY染色体を1つ持っています。
Biopython-表現型マイクロアレイ
表現型は、特定の化学物質または環境に対して生物が示す観察可能な特性または特性として定義されます。 表現型マイクロアレイは、多数の化学物質および環境に対する生物の反応を同時に測定し、データを分析して遺伝子変異、遺伝子特性などを理解します。
Biopythonは、表現型データを分析するための優れたモジュールBio.Phenotypeを提供します。 この章では、表現型マイクロアレイデータを解析、補間、抽出、分析する方法を学びましょう。
構文解析
表現型マイクロアレイデータは、CSVとJSONの2つの形式になります。 Biopythonは両方の形式をサポートしています。 Biopythonパーサーは、表現型マイクロアレイデータを解析し、PlateRecordオブジェクトのコレクションとして返します。 各PlateRecordオブジェクトには、WellRecordオブジェクトのコレクションが含まれています。 各WellRecordオブジェクトは、8行12列の形式でデータを保持します。 8行はAからHで表され、12列は01から12で表されます。 たとえば、4 ^ th ^行と6 ^ th ^列はD06で表されます。
次の例で構文の形式と概念を理解しましょう-
- ステップ1 *-Biopythonチームが提供するPlates.csvファイルをダウンロードします-https://raw.githubusercontent.com/biopython/biopython/master/Doc/examples/Plates.csv
- ステップ2 *-以下のようにphenotpeモジュールをロードします-
>>> from Bio import phenotype- ステップ3 *-データファイルとフォーマットオプション（「pm-csv」）を渡すphenotype.parseメソッドを呼び出します。 以下のように反復可能なPlateRecordを返します。
>>> 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']')]
>>>- ステップ4 *-リストの最初のプレートに以下のようにアクセスします-
>>> plate = plates[0]
>>> plate
PlateRecord('WellRecord['A01'], WellRecord['A02'], WellRecord['A03'], ...,
WellRecord['H12']')
>>>- ステップ5 *-前に説明したように、プレートにはそれぞれ12個のアイテムを持つ8つの行が含まれています。 WellRecordは以下に指定されているように2つの方法でアクセスすることができます-
>>> 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)')
>>>- ステップ6 *-各ウェルには異なる時点で一連の測定値があり、以下で指定するforループを使用してアクセスできます-
>>> 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
>>>補間
内挿により、データをより詳細に分析できます。 Biopythonは、WellRecordデータを補間して、中間時点の情報を取得するメソッドを提供します。 構文はリストのインデックス付けに似ているため、簡単に学習できます。
20.1時間でデータを取得するには、以下に指定されているように、単にインデックス値として渡します-
>>> well[20.10]
69.40000000000003
>>>開始時刻と終了時刻を渡すだけでなく、以下に指定することができます-
>>> well[20:30]
[67.0, 84.0, 102.0, 119.0, 135.0, 147.0, 158.0, 168.0, 179.0, 186.0]
>>>上記のコマンドは、1時間間隔で20時間から30時間のデータを補間します。 デフォルトでは、間隔は1時間であり、任意の値に変更できます。 たとえば、次のように15分（0.25時間）間隔を指定します-
>>> well[20:21:0.25]
[67.0, 73.0, 75.0, 81.0]
>>>分析および抽出
Biopythonは、Gompertz、Logistic、およびRichardsシグモイド関数を使用してWellRecordデータを分析するのに適したメソッドを提供します。 既定では、fitメソッドはGompertz関数を使用します。 タスクを完了するには、WellRecordオブジェクトのfitメソッドを呼び出す必要があります。 コーディングは次のとおりです-
>>> 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は高度な分析を行うためにscipyモジュールに依存しています。 scipyモジュールを使用せずに、min、max、average_heightの詳細を計算します。
Biopython-プロット
この章では、シーケンスのプロット方法について説明します。 このトピックに移る前に、プロットの基本を理解しましょう。
プロット
Matplotlibは、さまざまな形式で高品質の数値を生成するPythonプロットライブラリです。 折れ線グラフ、ヒストグラム、棒グラフ、円グラフ、散布図など、さまざまな種類のプロットを作成できます。
- pyLabは、数値モジュールnumpyとグラフィカルプロットモジュールpyplotを組み合わせたmatplotlibに属するモジュールです。** Biopythonは、シーケンスのプロットにpylabモジュールを使用します。 これを行うには、以下のコードをインポートする必要があります-
import pylabインポートする前に、pipコマンドと以下のコマンドを使用してmatplotlibパッケージをインストールする必要があります-
pip install matplotlibサンプル入力ファイル
Biopythonディレクトリに plot.fasta という名前のサンプルファイルを作成し、次の変更を追加します-
>seq0 FQTWEEFSRAAEKLYLADPMKVRVVLKYRHVDGNLCIKVTDDLVCLVYRTDQAQDVKKIEKF
>seq1 KYRTWEEFTRAAEKLYQADPMKVRVVLKYRHCDGNLCIKVTDDVVCLLYRTDQAQDVKKIEKFHSQLMRLME
>seq2 EEYQTWEEFARAAEKLYLTDPMKVRVVLKYRHCDGNLCMKVTDDAVCLQYKTDQAQDVKKVEKLHGK
>seq3 MYQVWEEFSRAVEKLYLTDPMKVRVVLKYRHCDGNLCIKVTDNSVCLQYKTDQAQDV
>seq4 EEFSRAVEKLYLTDPMKVRVVLKYRHCDGNLCIKVTDNSVVSYEMRLFGVQKDNFALEHSLL
>seq5 SWEEFAKAAEVLYLEDPMKCRMCTKYRHVDHKLVVKLTDNHTVLKYVTDMAQDVKKIEKLTTLLMR
>seq6 FTNWEEFAKAAERLHSANPEKCRFVTKYNHTKGELVLKLTDDVVCLQYSTNQLQDVKKLEKLSSTLLRSI
>seq7 SWEEFVERSVQLFRGDPNATRYVMKYRHCEGKLVLKVTDDRECLKFKTDQAQDAKKMEKLNNIFF
>seq8 SWDEFVDRSVQLFRADPESTRYVMKYRHCDGKLVLKVTDNKECLKFKTDQAQEAKKMEKLNNIFFTLM
>seq9 KNWEDFEIAAENMYMANPQNCRYTMKYVHSKGHILLKMSDNVKCVQYRAENMPDLKK
>seq10 FDSWDEFVSKSVELFRNHPDTTRYVVKYRHCEGKLVLKVTDNHECLKFKTDQAQDAKKMEK折れ線グラフ
次に、上記のfastaファイルの単純なラインプロットを作成しましょう。
- ステップ1 *-SeqIOモジュールをインポートして、fastaファイルを読み取ります。
>>> from Bio import SeqIO- ステップ2 *-入力ファイルを解析します。
>>> records = [len(rec) for rec in SeqIO.parse("plot.fasta", "fasta")]
>>> len(records)
11
>>> max(records)
72
>>> min(records)
57- ステップ3 *-pylabモジュールをインポートしましょう。
>>> import pylab- ステップ4 *-x軸とy軸のラベルを割り当てて折れ線グラフを構成します。
>>> pylab.xlabel("sequence length")
Text(0.5, 0, 'sequence length')
>>> pylab.ylabel("count")
Text(0, 0.5, 'count')
>>>- ステップ5 *-グリッド表示を設定して折れ線グラフを構成します。
>>> pylab.grid()- ステップ6 *-plotメソッドを呼び出し、入力としてレコードを提供することにより、単純な折れ線グラフを描画します。
>>> pylab.plot(records)
[<matplotlib.lines.Line2D object at 0x10b6869d 0>]- ステップ7 *-最後に以下のコマンドを使用してチャートを保存します。
>>> pylab.savefig("lines.png")結果
上記のコマンドを実行すると、Biopythonディレクトリに次の画像が保存されます。
ヒストグラムチャート
ヒストグラムは連続データに使用され、ビンはデータの範囲を表します。 ヒストグラムの描画は、pylab.plotを除いて折れ線グラフと同じです。 代わりに、レコード（bin）のcustum値を使用して、pylabモジュールのhistメソッドを呼び出します（5）。 完全なコーディングは次のとおりです-
- ステップ1 *-SeqIOモジュールをインポートして、fastaファイルを読み取ります。
>>> from Bio import SeqIO- ステップ2 *-入力ファイルを解析します。
>>> records = [len(rec) for rec in SeqIO.parse("plot.fasta", "fasta")]
>>> len(records)
11
>>> max(records)
72
>>> min(records)
57- ステップ3 *-pylabモジュールをインポートしましょう。
>>> import pylab- ステップ4 *-x軸とy軸のラベルを割り当てて折れ線グラフを構成します。
>>> pylab.xlabel("sequence length")
Text(0.5, 0, 'sequence length')
>>> pylab.ylabel("count")
Text(0, 0.5, 'count')
>>>- ステップ5 *-グリッド表示を設定して折れ線グラフを構成します。
>>> pylab.grid()- ステップ6 *-plotメソッドを呼び出し、入力としてレコードを提供することにより、単純な折れ線グラフを描画します。
>>> pylab.hist(records,bins=5)
(array([2., 3., 1., 3., 2.]), array([57., 60., 63., 66., 69., 72.]), <a list
of 5 Patch objects>)
>>>- ステップ7 *-最後に以下のコマンドを使用してチャートを保存します。
>>> pylab.savefig("hist.png")結果
上記のコマンドを実行すると、Biopythonディレクトリに次の画像が保存されます。
シーケンスのGCパーセンテージ
GCパーセンテージは、さまざまなシーケンスを比較するために一般的に使用される分析データの1つです。 一連のシーケンスのGCパーセンテージを使用して簡単な折れ線グラフを作成し、すぐに比較できます。 ここでは、データをシーケンス長からGCパーセンテージに変更するだけです。 完全なコーディングは以下のとおりです-
- ステップ1 *-SeqIOモジュールをインポートして、fastaファイルを読み取ります。
>>> from Bio import SeqIO- ステップ2 *-入力ファイルを解析します。
>>> from Bio.SeqUtils import GC
>>> gc = sorted(GC(rec.seq) for rec in SeqIO.parse("plot.fasta", "fasta"))- ステップ3 *-pylabモジュールをインポートしましょう。
>>> import pylab- ステップ4 *-x軸とy軸のラベルを割り当てて折れ線グラフを構成します。
>>> pylab.xlabel("Genes")
Text(0.5, 0, 'Genes')
>>> pylab.ylabel("GC Percentage")
Text(0, 0.5, 'GC Percentage')
>>>- ステップ5 *-グリッド表示を設定して折れ線グラフを構成します。
>>> pylab.grid()- ステップ6 *-plotメソッドを呼び出し、入力としてレコードを提供することにより、単純な折れ線グラフを描画します。
>>> pylab.plot(gc)
[<matplotlib.lines.Line2D object at 0x10b6869d 0>]- ステップ7 *-最後に以下のコマンドを使用してチャートを保存します。
>>> pylab.savefig("gc.png")結果
上記のコマンドを実行すると、Biopythonディレクトリに次の画像が保存されます。
Biopython-クラスター分析
一般に、クラスター分析は、同じグループ内のオブジェクトのセットをグループ化します。 この概念は、主にデータマイニング、統計データ分析、機械学習、パターン認識、画像分析、バイオインフォマティクスなどで使用されます。 クラスターがさまざまな分析でどのように広く使用されているかを理解するために、さまざまなアルゴリズムによって実現できます。
バイオインフォマティクスによると、クラスター分析は主に遺伝子発現データ分析で使用され、類似した遺伝子発現を持つ遺伝子のグループを見つけます。
この章では、実際のデータセットでのクラスタリングの基礎を理解するために、Biopythonの重要なアルゴリズムを確認します。
Biopythonは、すべてのアルゴリズムを実装するためにBio.Clusterモジュールを使用します。 次のアルゴリズムをサポートしています-
- 階層的クラスタリング
- K-クラスタリング
- 自己組織化マップ
- 主成分分析
上記のアルゴリズムについて簡単に紹介します。
階層的クラスタリング
階層的クラスタリングを使用して、距離測定によって各ノードをその最近傍にリンクし、クラスターを作成します。 Bio.Clusterノードには、左、右、距離の3つの属性があります。 以下に示すように簡単なクラスターを作成しましょう-
>>> from Bio.Cluster import Node
>>> n = Node(1,10)
>>> n.left = 11
>>> n.right = 0
>>> n.distance = 1
>>> print(n)
(11, 0): 1あなたがツリーベースのクラスタリングを構築したい場合は、以下のコマンドを使用します-
>>> 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.2Bio.Clusterモジュールを使用して階層クラスタリングを実行しましょう。
距離が配列で定義されていることを考慮してください。
>>> import numpy as np
>>> distance = array([[Now add the distance array in tree cluster.
[source,prettyprint,notranslate]>>> Bio.Clusterからtreeclusterをインポート>>> cluster = treecluster（distance）>>> print（cluster）（2、1）：0.666667（-1、0）：9.66667
The above function returns a Tree cluster object. This object contains nodes where the number of items are clustered as rows or columns.
=== K - Clustering
It is a type of partitioning algorithm and classified into k - means, medians and medoids clustering. Let us understand each of the clustering in brief.
==== K-means Clustering
This approach is popular in data mining. The goal of this algorithm is to find groups in the data, with the number of groups represented by the variable K.
The algorithm works iteratively to assign each data point to one of the K groups based on the features that are provided. Data points are clustered based on feature similarity.
[source,prettyprint,notranslate]>>> Bio.Clusterからkclusterをインポート>>> numpyから配列をインポート>>> data = array（[[clusterid、error、found = kcluster（data）>>> print（clusterid）[0 0 1] >>>印刷（見つかった）1
==== K-medians Clustering
It is another type of clustering algorithm which calculates the mean for each cluster to determine its centroid.
==== K-medoids Clustering
This approach is based on a given set of items, using the distance matrix and the number of clusters passed by the user.
Consider the distance matrix as defined below −
[source,result,notranslate]>>> distance = array（[[以下のコマンドを使用してk-medoidクラスタリングを計算できます-
>>> from Bio.Cluster import kmedoids
>>> clusterid, error, found = kmedoids(distance)例を考えてみましょう。
kcluster関数は、Seqインスタンスではなくデータ行列を入力として受け取ります。 シーケンスを行列に変換し、それをkcluster関数に提供する必要があります。
データを数値要素のみを含む行列に変換する1つの方法は、 numpy.fromstring 関数を使用することです。 基本的に、シーケンス内の各文字を対応するASCII文字に変換します。
これにより、kcluster関数が認識し、シーケンスのクラスター化に使用するエンコードされたシーケンスの2D配列が作成されます。
>>> 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]自己組織化マップ
このアプローチは、人工ニューラルネットワークの一種です。 これはコホネンによって開発され、しばしばコホネンマップと呼ばれます。 長方形のトポロジーに基づいてアイテムをクラスターに編成します。
以下に示すように、同じ配列距離を使用して簡単なクラスターを作成しましょう-
>>> from Bio.Cluster import somcluster
>>> from numpy import array
>>> data = array([[clusterid,map = somcluster(data)
>>> print(map)
[[print(clusterid)
[[Here, *clusterid *is an array with two columns, where the number of rows is equal to the number of items that were clustered, and* data* is an array with dimensions either rows or columns.
=== Principal Component Analysis
Principal Component Analysis is useful to visualize high-dimensional data. It is a method that uses simple matrix operations from linear algebra and statistics to calculate a projection of the original data into the same number or fewer dimensions.
Principal Component Analysis returns a tuple columnmean, coordinates, components, and eigenvalues. Let us look into the basics of this concept.
[source,prettyprint,notranslate]>>> numpy import arrayから>>> numpy import meanから>>> numpy import covから>>> numpy.linalg import eigから
＃行列を定義>>> A = array（[[print（A）[[各列の平均を計算>>> M = mean（A.T、axis = 1）>>> print（M） [ 3. 4.]
＃列の平均を引くことで列を中央に配置>>> C = A-M
>>> print（C）[[中心行列の共分散行列を計算>>> V = cov（C.T）
>>> print（V）[[共分散行列の固有分解>>>値、ベクトル= eig（V）
>>> print（vectors）[[print（values） [ 8. 0.]
Let us apply the same rectangular matrix data to Bio.Cluster module as defined below −
[source,prettyprint,notranslate]>>> Bio.Clusterからpcaをインポート>>> numpyから配列をインポート>>> data = array（[[columnmean、axes、components、eigenvalues = pca（data）>>> print（columnmean） [ 3. 4.] >>> print（coordinates）[[print（components）[[print（eigenvalues） [ 4. 0.]
Biopython-機械学習
バイオインフォマティクスは、機械学習アルゴリズムを適用する優れた分野です。 ここには、多数の生物の遺伝情報があり、これらすべての情報を手動で分析することはできません。 適切な機械学習アルゴリズムを使用すると、これらのデータから多くの有用な情報を抽出できます。 Biopythonは、教師付き機械学習を行うための有用なアルゴリズムセットを提供します。
教師あり学習は、入力変数（X）と出力変数（Y）に基づいています。 アルゴリズムを使用して、入力から出力へのマッピング関数を学習します。 以下に定義されています-
Y = f(X)このアプローチの主な目的は、マッピング関数を近似することです。新しい入力データ（x）がある場合、そのデータの出力変数（Y）を予測できます。
ロジスティック回帰モデル
ロジスティック回帰は、教師あり機械学習アルゴリズムです。 予測変数の加重和を使用してKクラス間の差を見つけるために使用されます。 イベント発生の確率を計算し、癌の検出に使用できます。
Biopythonは、ロジスティック回帰アルゴリズムに基づいて変数を予測するBio.LogisticRegressionモジュールを提供します。 現在、Biopythonは2つのクラス（K = 2）に対してのみロジスティック回帰アルゴリズムを実装しています。
k最近傍
k最近傍も教師あり機械学習アルゴリズムです。 最近傍に基づいてデータを分類することにより機能します。 Biopythonは、k最近傍アルゴリズムに基づいて変数を予測するBio.KNNモジュールを提供します。
ナイーブベイズ
単純ベイズ分類器は、ベイズの定理に基づいた分類アルゴリズムのコレクションです。 それは単一のアルゴリズムではなく、すべてが共通の原則を共有するアルゴリズムのファミリーです。 分類されるフィーチャのペアはすべて互いに独立しています。 Biopythonは、Naive Bayesアルゴリズムで動作するBio.NaiveBayesモジュールを提供します。
マルコフモデル
マルコフモデルは、確率変数の集合として定義される数学的システムであり、特定の確率的ルールに従って、ある状態から別の状態への遷移を経験します。 Biopythonは、マルコフモデルで動作する* Bio.MarkovModelおよびBio.HMM.MarkovModelモジュールを提供します*。
Biopython-テスト手法
Biopythonには、さまざまな条件下でソフトウェアをテストするための広範なテストスクリプトがあり、ソフトウェアにバグがないことを確認します。 テストスクリプトを実行するには、Biopythonのソースコードをダウンロードしてから、以下のコマンドを実行します-
python run_tests.pyこれにより、すべてのテストスクリプトが実行され、次の出力が得られます-
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
...........................................
...........................................また、以下に指定されているように個々のテストスクリプトを実行することもできます-
python test_AlignIO.py結論
私たちが学んだように、Biopythonはバイオインフォマティクスの分野で重要なソフトウェアの1つです。 Pythonで記述されているため（学習および記述が容易）、バイオインフォマティクスの分野でのあらゆる計算および操作に対処するための広範な機能を提供します。 また、ほとんどすべての一般的なバイオインフォマティクスソフトウェアに簡単で柔軟なインターフェイスを提供して、その機能も活用しています。
