基因组测序模拟

杨利霞

基因组测序模拟
基因组测序模拟

5 u1 t, {: G; l; U7 s! q; l  Q一、摘要

; {- K( W' G* Z' [9 [* E通过熟悉已有的基因组测序模拟和评估程序，加深全基因组鸟枪法测序原理的理解，并且能够编写程序模拟全基因组鸟枪法测序，理解覆盖度、测序深度、拷贝数等概念，设置测序相关参数，生成单端/双端测序结果文件
8 Z6 e) r  S/ L  [/ a3 g% O3 ^
二、材料和方法
. A6 C5 V/ G4 F% Z& F& {& h
1、硬件平台
) H% I4 F  z" D1 s! I8 L& O* F
处理器:Intel（R） Core（TM）i7-4710MQ CPU @ 2.50GHz
9 T4 g. ?0 @$ r) W" r* r安装内存(RAM)：16.0GB
# j5 |) B" I4 k( d; E- L4 W
% f8 f, H% A: j0 H1 T' `& }2、系统平台
4 [1 S, c) a, R% L+ Y. W3 S2 BWindows 8.1，Ubuntu

3、软件平台
" C" u' s$ v& Y
* W; ]( U/ B, ]( N% f  ^art_454
GenomeABC http://crdd.osdd.net/raghava/genomeabc/
! H6 ?1 s9 K8 Z3 X, U: A8 jPython3.5
  `' d6 P1 }7 F1 g" ^- L1 q: WBiopython
7 S% g$ k; C; l7 a- a7 H4、数据库资源

5 U( {7 r# D- d/ X0 ZNCBI数据库：https://www.ncbi.nlm.nih.gov/
8 q" ]9 w' f. H/ d
5、研究对象

酵母基因组Saccharomyces cerevisiae S288c (assembly R64)
" _9 M1 d. o6 c; G: o: Oftp://ftp.ncbi.nlm.nih.gov/genomes/all/GCF/000/146/045/GCF_000146045.2_R64/GCF_000146045.2_R64_genomic.fna.gz
! q) O: [3 L6 n5 B) d
* [6 {' G5 N+ i2 \" A8 V6、方法
) j) C; F% x: ^, r( M5 U
( A( E$ g. ^" ~) mart_454的使用
首先至art系列软件的官网，下载软件，在ubuntu系统安装，然后阅读相关参数设置的帮助文档，运行程序。
GenomeABC
* o6 [9 ~0 H- b" L6 T( C* z1 X" N进入GenomeABC(http://crdd.osdd.net/raghava/genomeabc/)，输入参数，获得模拟测序结果。
编程模拟测序
下载安装python，并且安装biopython扩展模块，编写程序，模拟单端/双端测序。
三、结果
8 O  U9 h( X" p4 B0 u  e9 q: V
1、art_454的运行结果

无参数art_454运行，阅读帮助文档

图表 1无参数art_454运行
对酵母基因组进行基因组单端测序模拟，FOLD_COVERAGE设为20，即覆盖度为20.
下图为模拟单端测序，程序运行过程及结果
* \1 P& `. S% w
图表 2 art454单端测序

) J0 X: O  |/ J" B* Y图表 3 art454单端模拟结果
3 X  b5 l0 S, k% ?) I2 P双端测序模拟，FOLD_COVERAGE设为20，即覆盖度为20；MEAN_FRAG_LEN设为1500，即平均片段长度为1500；STD_DEV设为20，即长度的标准差为20
下图为模拟双端测序，程序运行过程及结果
- I/ }5 ?+ S) j9 y. q
图表 4 art454双端测序
' `" M& J& X2 a! k* R5 s
1 m+ {5 n% o& y; W) a图表 5 art454双端模拟结果
2、GenomeABC
下图为设置参数页面

下图为结果下载页面

: `& Q$ p/ F8 A图表 6 结果下载页面
! M' k8 a, t5 R# v: Z3、编程模拟测序结果
拷贝数是这里的N值；覆盖度是m，测序深度是宏观的量，在这里与覆盖度意思相同，就是测序仪10X，20X。
$ h( f" h  S" F单端测序

图表 7 程序模拟单端测序
) e. \- t- ]' c2 e7 S双端测序
! V+ D% s7 z0 s& s1 H
7 V: g0 l& J* D' W: K7 i图表 8 程序模拟双端测序
测序结果

  g' N$ U# S5 R0 J4 M. u7 ^  J图表 9 结果文件
3 Z( t3 ~! W* t9 Y  o
  G: H' ?6 D* \! u4 v0 w: l因为期望片段长度是600bp，在片段长度区间200-1000bp内，所以大部分的片段都没有删除。
% R& g/ [+ K, s测序结果统计表
3 H  s' N9 T' o1 L( @
测序方式        基因组大小(bp)        片段长度区间 (bp)        N值        期望片段长度        克隆保留率        片段数量        Reads长度范围（bp）        Reads总数量        Reads总长度        覆盖度(m值)        理论丢失率(e-m)        覆盖率(1-e-m)
: ]0 d' ]% W4 c8 Y: ?) s4 l单端        12157kb        200-1000        10        600        0.95        107378        50-100        101968        7645.541kb        0.62889        0.53318        0.46682
单端        12157kb        200-1000        20        600        0.95        213722        50-100        202996        15227.882kb        1.25259        0.28576        0.71424
双端        12157kb        200-1000        10        600        0.95        106704        50-100        202770        15212.662kb        1.25134        0.28612        0.71388
% g( o% P# a5 a. E# ]$ {. `双端        12157kb        200-1000        20        600        0.95        214212        50-100        407186        30534.265kb        2.51164        0.08114        0.91886
四、讨论和结论

+ A# N- {0 b; y. \程序运行方法

! u4 n- [& O! p" k' x在类的构造方法init()中，调整参数。
, j; }' t! y+ O! O0 WAveragefragmentlength为片段平均的长度；
) A) f& G, W& m) R. a: H" {; e# ^minfragmentlength和maxfragmentlength是保留片段的范围；
3 N3 p9 ?, u4 c1 G3 UcloneRetainprobability是克隆的保留率；
minreadslength和maxreadslength是测序reads的长度范围
& t4 j( s& T! _/ ~1 t5 `
% D9 h. f+ |4 c模拟测序的诸多方法都封装成了Sequencing类，只需要创建类，并调用singlereadsequencing()和pairreadsequencing()方法，传入文件名的参数即可。

附录

from Bio import SeqIO
( V9 C' F" O, G; C; mfrom math import exp
import random

. i! C- g- l+ U1 c% v. G, I! Bclass Sequencing:
    # N代表拷贝份数
    def __init__(self)
        self.fragmentList = []
8 {: m, `0 }: \, d4 S        self.readsID = 1
6 a, C+ A) Q6 f        self.readsList = []
- o2 {  s6 E; L0 ~8 b        self.averagefragmentlength = 650
        self.minfragmentlength = 500
        self.maxfragmentlength = 800
        self.cloneRetainprobability = 1
        self.minreadslength = 50
        self.maxreadslength = 150
        self.N = 10
- Y5 ~- u$ n2 e        self.genomeLength = 0
        self.allreadslength = 0

    # 生成断裂点
    def generatebreakpoint(self, seqlen, averageLength):
% P3 V& D2 t; ~% p$ i* l3 E6 C) l4 p        # 假设平均每500bp 产生一个断裂点(averageLength = 500),通过随机函数生成seqlen/500个随机断裂点(1到seqlen之间的随机整数)
0 O7 K% F/ K! m, W4 R        breakpoint = [random.randint(0, seqlen) for _ in range(int(seqlen / averageLength))]
        breakpoint.append(seqlen)
        breakpoint.append(0)
; O/ ~; o8 a8 s        # 把随机断裂点从小到大排序
) @, v1 ]- b1 i$ \8 G1 w/ n* X  D        breakpoint.sort()
: r) j7 _8 P2 ]% V2 H        return breakpoint

9 }+ G# ?. j1 Z/ W4 c    # 沿断裂点打断基因组,并删除不符合长度要求的序列片段,定义片段范围:200-1000bp
    def breakgenome(self, seq, breakpoint, minfragmentlength, maxfragmentlength):
        for i in range(len(breakpoint) - 1):
+ x& ]1 o1 `- _5 |' u            fragment = seq[breakpoint:breakpoint[i + 1]]
( |  T5 ?, P: W$ b            if maxfragmentlength > len(fragment) > minfragmentlength:
                self.fragmentList.append(fragment)
        return self.fragmentList
: c7 Z  u. j( I4 v
* Z# E" V$ q. Y$ F: [    # 模拟克隆时的随机丢失情况,random.random()生成0-1的保留概率
9 N( R1 I8 `5 G% m) W    def clonefragment(self, fragmentList, cloneRetainprobability):
/ U$ N; m6 L1 @/ u3 m        clonedfragmentList = []
% f0 C4 y: d/ K        Lossprobability = [random.random() for _ in range(len(fragmentList))]
        for i in range(len(fragmentList)):
            if Lossprobability <= cloneRetainprobability:
% O* h  v9 a! e1 G7 L                clonedfragmentList.append(fragmentList)
        return clonedfragmentList

4 x5 j1 d% L( s9 H    # 模拟单端测序,并修改reads的ID号
- a) u( K0 ^# Q' D2 N    def singleread(self, clonedfragmentList):
8 b& Z% X5 L: x* N3 p( n% i        for fragment in clonedfragmentList:
1 d7 I1 A6 I) p* h" D8 m$ D& n            fragment.id = ""
& V4 V% H/ o' E            fragment.name = ""
            fragment.description = fragment.description[12:].split(",")[0]
1 b; u  t8 H& u8 S            fragment.description = str(self.readsID) + "." + fragment.description
            self.readsID += 1
) Q, |- h- X4 F5 I5 {            readslength = random.randint(self.minreadslength, self.maxreadslength)
            self.allreadslength += readslength
6 J- c8 a8 a* L' J: C' O2 }            self.readsList.append(fragment[:readslength])
) Z* B2 B0 w8 z- k' V8 y
    def singlereadsequencing(self, genomedata, sequencingResult):
) o* L. c* b" p) x  z& c, U% E/ X        for seq_record in SeqIO.parse(genomedata, "fasta"):
            seqlen = len(seq_record)
            self.genomeLength += seqlen
            for i in range(self.N):
  S8 Y% f! y$ A" o* \+ O                # 生成断裂点
) \! A* |/ {4 R+ P, {" f" a                breakpoint = self.generatebreakpoint(seqlen, self.averagefragmentlength)
                # 沿断裂点打断基因组
                self.breakgenome(seq_record, breakpoint, self.minfragmentlength, self.maxfragmentlength)
        # 模拟克隆时的随机丢失情况
' u) `( l  p4 s9 }8 K# A$ c1 ?& W) y9 O        clonedfragmentList = self.clonefragment(self.fragmentList, self.cloneRetainprobability)
        # 模拟单端测序
        self.singleread(clonedfragmentList)
        SeqIO.write(self.readsList, sequencingResult, "fasta")

9 x0 ~7 B  A5 f- e, F    def pairread(self, clonedfragmentList):
8 R+ u, N6 l) g! \, R        for fragment in clonedfragmentList:
            fragment.id = ""
            fragment.name = ""
            description = fragment.description[12:].split(",")[0]
# M" v0 e2 u+ i3 O( Y            fragment.description = str(self.readsID) + "." + description
) o$ o# q; i& a; w            readslength = random.randint(self.minreadslength, self.maxreadslength)
            self.allreadslength += readslength
; @) k0 d3 _" Q6 U1 c8 F) q            self.readsList.append(fragment[:readslength])

5 F" T- ]- E( q! f: Y# k* W            readslength = random.randint(self.minreadslength, self.maxreadslength)
( W; b, k% `( d- J! ]+ D            self.allreadslength += readslength

            fragmentcomplement = fragment.reverse_complement()
: w+ a+ [, T/ q8 p  ]/ A3 w            fragmentcomplement.id = ""
            fragmentcomplement.name = ""
            fragmentcomplement.description = str(self.readsID) + "." + description
            self.readsList.append(fragmentcomplement[:readslength])
$ W: Z& s. t& E! y: k: H! S6 D
2 j) |& i, z2 M, A            self.readsID += 1

6 \! w" p5 e& {" U: p0 M2 O    def pairreadsequencing(self,genomedata, sequencingResult_1, sequencingResult_2):
. I8 l* Q) X8 Q1 n. s, x3 k5 l        for seq_record in SeqIO.parse(genomedata, "fasta"):
            seqlen = len(seq_record)
; e/ q7 c( T* g9 p# H2 M4 O  g0 I            self.genomeLength += seqlen
            for i in range(self.N):
                # 生成断裂点
2 @8 ]* R1 h/ ~0 I( C9 ~                breakpoint = self.generatebreakpoint(seqlen, self.averagefragmentlength)
' l6 t4 }% ]7 U. j% G9 `4 w& D                # 沿断裂点打断基因组
; S  f, N2 A# o. \  t1 c4 Y                self.breakgenome(seq_record, breakpoint, self.minfragmentlength, self.maxfragmentlength)
        # 模拟克隆时的随机丢失情况
        clonedfragmentList = self.clonefragment(self.fragmentList, self.cloneRetainprobability)
: ]7 A* `. T  n! @        # 模拟双端测序
        self.pairread(clonedfragmentList)
3 W  l0 S8 w+ B% g& i' a& K        readsList_1 = [self.readsList for i in range(len(self.readsList)) if i % 2 == 0]
9 E# ?5 Z; G) Q0 o/ C( ^  Z        readsList_2 = [self.readsList for i in range(len(self.readsList)) if i % 2 == 1]
1 Y6 I& J1 k* l        SeqIO.write(readsList_1, sequencingResult_1, "fasta")
        SeqIO.write(readsList_2, sequencingResult_2, "fasta")
# m, z' Q! i9 O1 ?
0 |: ~! n) O7 N8 y! t! r: w    def resultsummary(self):
8 q: [1 H: L  I% A! l        print("基因组长度:" + str(self.genomeLength / 1000) + "kb")
        print("片段长度区间:" + str(self.minfragmentlength) + "-" + str(self.maxfragmentlength))
        print("N值:" + str(self.N))
        print("期望片段长度:" + str(self.averagefragmentlength))
! Z( f; w4 Z! I& X3 t: |* m. J        print("克隆保留率:" + str(self.cloneRetainprobability))
        print("片段数量:" + str(len(self.fragmentList)))
        print("reads长度:" + str(self.minreadslength) + "-" + str(self.maxreadslength))
        print("reads总数量:" + str(len(self.readsList)))
: g* Q% \) h5 @3 I/ y        print("reads总长度:" + str(self.allreadslength / 1000) + "kb")
        m = self.allreadslength / self.genomeLength
        print("覆盖度(m值):" + str(round(m, 5)))
) j% b% B9 W0 _, _        print("理论丢失率(e^-m):" + str(round(exp(-m), 5)))
        print("覆盖率(1-e^-m):" + str(round(1 - exp(-m), 5)))
9 V1 ]' z9 a: m; ~4 w8 U# -------------------------------------------主程序-------------------------------------------
# 模拟单端测序
8 g6 d1 w2 _( z5 EsequencingObj = Sequencing()
sequencingObj.singlereadsequencing("data/NC_025452.fasta", "result/virusSingleRead.fa")
sequencingObj.resultsummary()
& S5 k6 w' y: R
# 模拟双端测序
1 z% Z! s! T! z3 B( msequencingObj = Sequencing()
sequencingObj.pairreadsequencing("data/GCF_000146045.2_R64_genomic.fna", "result/yeastPairRead_1.fa", "result/yeastPairRead_2.fa")
sequencingObj.resultsummary()
- E1 ^5 |0 F* r# l8 `3 Ffrom Bio import SeqIO
from math import exp
: t9 Z" N5 y, F) `3 v( Q# zimport random

class Sequencing:
    # N代表拷贝份数
- q" g: z. E- W9 }+ `    def __init__(self):
        self.fragmentList = []
        self.readsID = 1
  ~1 g6 b! Q! M! a$ p        self.readsList = []
, U7 ?+ l+ G) K5 Z' P" k- S0 }        self.averagefragmentlength = 650
        self.minfragmentlength = 500
        self.maxfragmentlength = 800
        self.cloneRetainprobability = 1
        self.minreadslength = 50
* U; w; }+ E0 \, [        self.maxreadslength = 150
        self.N = 10
        self.genomeLength = 0
        self.allreadslength = 0

2 r! K4 T+ C( |* T8 M    # 生成断裂点
! I% f& O1 y2 D, C. Q9 ^- m4 E4 b4 U    def generatebreakpoint(self, seqlen, averageLength):
        # 假设平均每500bp 产生一个断裂点(averageLength = 500),通过随机函数生成seqlen/500个随机断裂点(1到seqlen之间的随机整数)
1 n9 W, G9 R% k; g% a        breakpoint = [random.randint(0, seqlen) for _ in range(int(seqlen / averageLength))]
% X4 H9 T* v! `- O! z        breakpoint.append(seqlen)
        breakpoint.append(0)
        # 把随机断裂点从小到大排序
        breakpoint.sort()
: C; |+ A: M/ o4 ]; `        return breakpoint
% L; c+ A4 a$ J( w
    # 沿断裂点打断基因组,并删除不符合长度要求的序列片段,定义片段范围:200-1000bp
    def breakgenome(self, seq, breakpoint, minfragmentlength, maxfragmentlength):
8 X, }* k; Q+ A1 r4 R* a. [        for i in range(len(breakpoint) - 1):
            fragment = seq[breakpoint:breakpoint[i + 1]]
            if maxfragmentlength > len(fragment) > minfragmentlength:
                self.fragmentList.append(fragment)
        return self.fragmentList
; ]% M3 `, U2 ]4 J
$ l* C& u; t6 I7 z) W    # 模拟克隆时的随机丢失情况,random.random()生成0-1的保留概率
( U& X& J; A/ s0 R. ], ~0 L# J0 d    def clonefragment(self, fragmentList, cloneRetainprobability):
        clonedfragmentList = []
) h4 G3 O7 a. G$ |+ b' M* I9 W        Lossprobability = [random.random() for _ in range(len(fragmentList))]
6 Z- B) A1 j1 }+ ]5 X* b        for i in range(len(fragmentList)):
5 r. \% Z8 S& t: s! G3 D# Q            if Lossprobability <= cloneRetainprobability:
9 ?$ N, _& z: j8 r! i8 x                clonedfragmentList.append(fragmentList)
        return clonedfragmentList
0 y8 R, b+ s3 B) |7 t
# ^  R$ v: S9 J$ A* }7 C    # 模拟单端测序,并修改reads的ID号
    def singleread(self, clonedfragmentList):
4 l. m5 S! ?' E# T8 M. j- k$ C6 B        for fragment in clonedfragmentList:
            fragment.id = ""
( A, L: o- q/ p: q- o" y! Z2 ^            fragment.name = ""
6 u3 t: a" b# m  G3 Z( X  f# |- A            fragment.description = fragment.description[12:].split(",")[0]
            fragment.description = str(self.readsID) + "." + fragment.description
  S2 B; |6 s. @) q' P' @: b            self.readsID += 1
4 s2 J- M+ H( Y1 ^            readslength = random.randint(self.minreadslength, self.maxreadslength)
7 G+ e7 K  J' w  B            self.allreadslength += readslength
            self.readsList.append(fragment[:readslength])
- @0 i: j6 S7 b' q
    def singlereadsequencing(self, genomedata, sequencingResult):
9 p+ r3 g  u* Z' h1 ~! H' N        for seq_record in SeqIO.parse(genomedata, "fasta"):
" G0 }$ b9 a& H+ F8 H            seqlen = len(seq_record)
            self.genomeLength += seqlen
0 |, S, h$ d7 b. t. w: @            for i in range(self.N):
) b0 H( E7 c5 d0 @+ v8 V                # 生成断裂点
6 V; v4 C0 g9 B" N                breakpoint = self.generatebreakpoint(seqlen, self.averagefragmentlength)
                # 沿断裂点打断基因组
                self.breakgenome(seq_record, breakpoint, self.minfragmentlength, self.maxfragmentlength)
        # 模拟克隆时的随机丢失情况
        clonedfragmentList = self.clonefragment(self.fragmentList, self.cloneRetainprobability)
  T- Z5 V" O% I1 _! u4 `        # 模拟单端测序
9 G  u. L$ z7 D: i        self.singleread(clonedfragmentList)
        SeqIO.write(self.readsList, sequencingResult, "fasta")
' F! j$ {5 T! s
    def pairread(self, clonedfragmentList):
        for fragment in clonedfragmentList:
            fragment.id = ""
            fragment.name = ""
            description = fragment.description[12:].split(",")[0]
            fragment.description = str(self.readsID) + "." + description
& \6 w4 H% Z/ u, k# r6 O            readslength = random.randint(self.minreadslength, self.maxreadslength)
0 \5 B" W' o8 c3 E7 j0 _            self.allreadslength += readslength
1 y; b. S1 i$ @            self.readsList.append(fragment[:readslength])
. F, n! }6 s  l* D8 A
4 j' T* `5 x6 N: W, _            readslength = random.randint(self.minreadslength, self.maxreadslength)
  l3 [/ y- G7 d# ~' v            self.allreadslength += readslength

) H) M/ j6 v. Y% i1 m            fragmentcomplement = fragment.reverse_complement()
            fragmentcomplement.id = ""
: L$ u- V9 `+ I0 O/ o8 p            fragmentcomplement.name = ""
            fragmentcomplement.description = str(self.readsID) + "." + description
            self.readsList.append(fragmentcomplement[:readslength])

7 o! S' `7 `0 y; r# h  K            self.readsID += 1

    def pairreadsequencing(self,genomedata, sequencingResult_1, sequencingResult_2):
3 ]* z! V6 t3 Q: v0 B        for seq_record in SeqIO.parse(genomedata, "fasta"):
0 o# w) w' A/ |            seqlen = len(seq_record)
            self.genomeLength += seqlen
+ t4 p9 D2 o& s8 J; L) |- w            for i in range(self.N):
                # 生成断裂点
7 H8 J6 m8 g* b! Y; P$ d                breakpoint = self.generatebreakpoint(seqlen, self.averagefragmentlength)
                # 沿断裂点打断基因组
                self.breakgenome(seq_record, breakpoint, self.minfragmentlength, self.maxfragmentlength)
        # 模拟克隆时的随机丢失情况
2 m' `; @6 n: k+ q* c+ t0 H! A        clonedfragmentList = self.clonefragment(self.fragmentList, self.cloneRetainprobability)
3 R+ C3 c& F# D        # 模拟双端测序
        self.pairread(clonedfragmentList)
8 @8 f" L% P$ ?2 g, B, q7 z        readsList_1 = [self.readsList for i in range(len(self.readsList)) if i % 2 == 0]
# V/ g/ U6 t0 {4 k. t        readsList_2 = [self.readsList for i in range(len(self.readsList)) if i % 2 == 1]
        SeqIO.write(readsList_1, sequencingResult_1, "fasta")
6 P3 Z5 _1 A; ]: P        SeqIO.write(readsList_2, sequencingResult_2, "fasta")

2 C, c1 ~, u8 M/ ]1 O7 G! U: O+ A0 Q    def resultsummary(self):
        print("基因组长度:" + str(self.genomeLength / 1000) + "kb")
        print("片段长度区间:" + str(self.minfragmentlength) + "-" + str(self.maxfragmentlength))
        print("N值:" + str(self.N))
        print("期望片段长度:" + str(self.averagefragmentlength))
        print("克隆保留率:" + str(self.cloneRetainprobability))
" H3 H7 A8 j% H; |        print("片段数量:" + str(len(self.fragmentList)))
: o1 H4 y% C  E1 [6 ^        print("reads长度:" + str(self.minreadslength) + "-" + str(self.maxreadslength))
        print("reads总数量:" + str(len(self.readsList)))
' _" h' [, {) h2 C6 J        print("reads总长度:" + str(self.allreadslength / 1000) + "kb")
        m = self.allreadslength / self.genomeLength
        print("覆盖度(m值):" + str(round(m, 5)))
        print("理论丢失率(e^-m):" + str(round(exp(-m), 5)))
/ v: X  X  c# x- t        print("覆盖率(1-e^-m):" + str(round(1 - exp(-m), 5)))
. p2 K' ]2 {6 p/ O, W: i# -------------------------------------------主程序-------------------------------------------
# 模拟单端测序
+ P; H4 S/ S* o# gsequencingObj = Sequencing()
+ j$ S/ `" ~; |/ \+ p4 ]9 Z' ssequencingObj.singlereadsequencing("data/NC_025452.fasta", "result/virusSingleRead.fa")
- g# a3 @+ y- }& R; osequencingObj.resultsummary()
4 m' L: @& S  a& Q; `# U
# d$ e  p6 {5 O$ g( O$ h0 d. N# 模拟双端测序
8 `  B( m' w2 ?) n: j$ R* M- MsequencingObj = Sequencing()
2 p( @2 Y& J0 @5 tsequencingObj.pairreadsequencing("data/GCF_000146045.2_R64_genomic.fna", "result/yeastPairRead_1.fa", "result/yeastPairRead_2.fa")
, |7 |& t# C! L$ J7 BsequencingObj.resultsummary()
- f3 b. F9 J) j9 F



5 V. ^- b) i2 d9 F$ R$ p8 |4 M5 |

3477959497

不错。。。。。。。。。。。。。。。。。