卢宏超...
TRANSCRIPT
卢宏超
2017年1月
**高通量技术使生物信息变得热门。大量的组学数据需要收集、处理、分析和管理。
*基因组、蛋白组、转录组、非编码、表观遗传、微生物组、系统生物学。。。。。。
*药物设计、生物工程、遗传检测、新生儿筛查、肿瘤靶向治疗、生物育种。。。。。
*特点：数据量大，软件多样，格式繁多
*应用举例：
*处理ＢＬＡＳＴ结果，综合分析
*产生具有特定ＧＣ含量的随机序列
*整理分析蛋白质相互作用网络
*批量设计引物
*蛋白质三维结构分析
*提，算，滤、排、转，联，绘
*提就是你有个表，想从另一个（或几个，有时是几个文件才能联系上）数据库或大文件里提出想要的列表对应的信息。
*算就是文件里有一些数值，将这些数值按照模型进行计算。
*滤就是从一个大数据中过滤数据出小数据集数据，并进行数据清洗。
*排就是排序，是对一个数据列表的按某个字段排序。
*转就是将一个有规律的文本文件转换成另一个很规则的文本文件，因为一些软件的输入的要求，或者是为了别人看的方便。
*联就是胶合几个现有的程序，形成程序流程。
*绘就是绘制科学图表。
https://www.zhihu.com/question/24986275/answer/29688735
**编程是给计算机一张菜谱，
*而计算机是一个弱智但高效的厨子。
*如果你不能把材料（数据）和步骤（方法或函数）清晰地告诉计算机。它什么不能做。
*所以编程实际上程序员思想的体现，没有搞清楚算法逻辑和数据结构之前，不要轻易开始书写代码。
*如果方法学被确认较复杂，先学习相应的算法与数据结构课程或是统计学课程，或是请教专家。
*
统计网站调研显示Python, R, SQL是统计学加的三板斧。http://www.kdnuggets.com/polls/2013/languages-analytics-data-mining-data-science.html
BioSTAR推荐生物信息初学语言为Python
*PERL Python
面向过程 面向对象
简单易学 较难，提高容易
语法结构不清晰 字母化语言，清晰
应用更广泛于系统、文本管理 广泛应用于数据管理、网站和大数据
主要用来写脚本 可以写较大的应用，不仅限于脚本
脚本的执行速度快 对面向对象编程，更容易和高效
第三方包管理cpan 第三方包管理Pypi
软件更新慢 活跃的开发社区
有BioPerl 有BioPython
老的生物信息软件多用perl 新的生物信息软件多用Python
*
**这里由Guido van Rossum，Python的作者描述“发明”
这一种新的计算机语言的动机，如下：
“我在阿米巴（Amoeba）分布式操作系统CWI系统组工作时，我们需要来做比通过编写C程序或Bourne shell脚本的方式进行系统管理的一种更好的方式。因为阿米巴有其自己的系统调用接口，不会轻易从Bourne shell进行访问。我在阿米巴的错误处理的经历使我敏锐地意识到作为一种编程语言功能的重要性。
我突然想到一种像ABC语法的脚本语言与阿米巴系统调用的访问将满足用户的需求。我意识到写一个阿米巴特定的语言将是愚蠢的，所以我决定我需要的语言能够有一般可扩展性。
1989年圣诞假期期间，我手头上有很多时间，所以我决定对它做一个尝试。在接下来的一年里，虽然仍有大多工作在我自己的时间里完成，它被成功地用在阿米巴项目中，并从同事的反馈中让我添加了许多早期的改进。
在1991年2月，仅仅经过了一年的开发后，我决定把它发表在USENET上。剩下的历史在Misc/HISTORY 文件中。
*在2009年1月，Guido开设了一个博客，专门用于Python的历史。它可以在这里被访问
** 可读性：当我们说到可读性的时候，我们指对原始的编程者而言，同样也指对于其他对理解这个代码感兴趣的任
何人。某个人在写了一些代码的一个月之后，再来看它时发现它非常得难理解，这样的情况不是非常稀罕的事件。而Python有时被称为“人就可以读的语言”。
* 解释性：在一个解释型的语言中，每行代码被一行行地翻译和执行。在编译语言中，首先整个程序被翻译，而后才被执行。执行编译型的语言一般比执行解释型的语言要快很多。但是，用户需要在每次有所改变时编译这个程序；而对解释型语言，用户可以立即看到改变后带来的效果，以此可以更快的写程序。因此，我们认为一个解释型的语言如Python对入门更容易。
* 自带属性：Python 与生俱来就“自带电池”，它含有丰富的多用途的标准库，不需要用户来下载分离的软件包。用Python你能够用很少的代码来读XML文件，提取zip包中的文件，解释和产生email信息，处理文件，读取和发送从Web浏览器到服务器的数据，打开一个URL就象打开一个文件，还有许多的可能性。
* 支持第三方模块：二维或三维画图，PDF产生器，生物信息分析，动画，游戏开发，与常见的数据库接口和应用软件，这些只是大量可以安装来扩展Python模块的例子的一部分。
* 高级的自带数据结构：字典（dictionaries），集合（sets），列表（lists）和元组（tuples），这些可以用来帮助对真实世界建模。
* 多范式编程：Python可以被用作“经典”的过程式语言，或是“现代”的面向对象编程（OOP）语言。大多数的编程者开始编代码都是通过过程方式，当他们准备好了，就升级到OOP方式。在编程者只想写简单的脚本时，Python不强迫编程者来写面向对象代码。
* 可扩展性：如果自带的方法和第三方的方法都不能满足你的需要，你可以轻易地扩展Python，甚至用其它的编程语言。在Python中有许多的应用是以前用C或Fortran语言开发的过程，Python也可以扩展来连接特殊化的高级语言，如R和MATLAB。
* 开放源码：Python有一个自由的开发源代码的证书，这使得它能免费使用和分发，商业应用也可以。
* 跨平台：一个用Python编的程序可以在任何具有Python解释器的计算机下运行。采取这个方式，一个在Windows Vista下开发的程序可以不加更改的在Linux下运行。Pyton解释器在大多数的计算机和操作系统上都有，甚至象有些嵌入式的计算机的设备（诸如Nokia 6630智能手机）中也有。
** CPython：这是 常用的Python版本，这里的名词CPython和Python是可以互换使用的。它大多是由C写成的（有一些模块是Python的），是在Python官方网站（http://www.python.org ）上的可用版本。
* PyPy：Python中的一个用Python写成的版本。它是设想让编程者以灵活的方式参与语言实验（改变Python代码而不需要知道C）。它基本是一个实验平台。
* Stackless是另一种实验性的Python实现。它的目标是这种实现不注重作为PyPy的灵活性，而是它提供了在“标准”Python版本不提供的先进功能。这样做是为了克服早在Python开发的历史中的一些设计做出的决定。 Stackless是允许定制设计的，它的Python应用程序的规模比CPython的同等程序更好。这个实施正在被大型多人在线游戏EVE Online中使用：Civilization IV，Second Life和Twisted。
* Jython：一个用Java编写的Python版本。它的原理是在一个JVM（JAVA虚拟机）上工作。 Jython的应用程序添加Jython的库到它们的Java系统来允许用户为应用程序添加功能。一个非常知名的学习3D编程的环境（Alice,注：http://www.alice.org 上免费得到）是使用Jython让用户编写自己的脚本。
* IronPython： Python版本适应微软上运行“.Net”和“.Mono”的平台。.Net是一种技术旨在与JAVA的关于“一次编写，运行无处不在。”进行竞争。另一个IronPython应用是由微软所设想的把它作为在Web上运行的脚本语言在Silverlight浏览器上运行（类似Flash的微软技术）。
*
*Python到现在有两个不相容的版本系列V2.x vs. V3.x*三点说明
*V3版本和V2版本在应用层面差别不大，除了print方法的格式变化外，其它主要功能，python2.x到3.x可以不经大改。
*大多数第三方软件仍是2.x系列开发的，所以我们这里仍以2.x做教程。
*V2到V3程序有软件做自动转换。
**Windows：
需要从www.python.org下载Python Windows安装器*.msi，要确保下载的是2.7以上版本的Python，3.x与本教程不兼容。Python可以像大多数程序一样通过点击并接受默认选项安装。
*MAC
同样从www.python.org下载Python MAC安装器。*.pkg.
*Linux中用sudo yum install python27
或sudo apt-get install python根据用户不同的系统选取，一般已默认安装。
如果没有系统管理员权限，可以让管理员安装。用户要安装自己的软件版本，需要看说明书和更多的操作系统知识。
**在Linux和Mac OS X系统下，你可以从文本控制台键入“python”然后按下回车。
*在Windows系统下，可以选择“开始”→“程序”→“Python2.7”→“Python（command line）”来打开一个独立的Python shell窗口；或者，你也可以在“开始”→“运行”键入“cmd” 打开文本控制台，然后改变路径到C:\Python27并键入“python”，当见到提示符>>>，安装就是成功了。
*在提示符下
*>>>1+1
*看看什么结果？
*>>>import this
*看看什么结果？
**下载《生物信息Python数据管理》代码
*下载Mercurial
*https://www.mercurial-scm.org/wiki/Download
*进入一个本地目录
*cd my_directory
*hg clone https://bitbucket.org/krother/python-for-biologists
*设置python命令路径
*Windows : computer->property->Advanced System Setting->Environment Variables在PATH变量 后加上
“;c:\python27”,注意是引号内内容，有一个分号
**大家先试着在交互模式带括号的加减乘除四则运算的效果
*Python中的数
*整数、浮点数
*整数运算结果还是整数，如果有浮点数参与则结果为浮点数
*内置转换函数int, float
运算符 含义
a + b 加
a – b 减
a * b 乘
a / b 除
a ** b 幂
a % b 取模，a/b的余数
a // b 向下舍入除法
a * ( b + c) 圆括号，b+c会在乘法之前进行运算
+=, ‐=, *=, /=, *=, **= 递归运算符。x += 1 等价于x = x + 1
表1.2Python中的算术运算符
开平方、求对数在哪？
*>>> a=1>>>a*100
* 计算中将要用到的值被放在已经命名的容器中，这个容器名称为变量名。
* 如a，s, PI,R等都可以作为，变量名。变量名要求
* 有些词在Python有含义所以不能被选作变量名，如import不能当作变量名，完整的保留字列表详见专题1.3；* 变量名的第一个字不能是数字；
* 变量名是大小写敏感的，因此var和Var是不同的名称；
* 大多数特殊符号，如$ % @ / \ . , [ ] ( ) { } 都是不能使用的。
* 专题1.3 Python中的保留字
* Python保留字在Python有含义所以不能被选作变量名，以下是一些例子：and，assert，break，class，continue，def，del，elif，else，except，exec，finally，for，from，global，if，import，in，is，lamda，not，or，pass，print，raise，return，try，while。** 变量名的赋值用等号
* 如PI=3.14159
Python解释器将一切作为对象，这意味着当你用一个新的变量名的时候，Python会识别数据类型（整数、浮点数、文本或其它）并为其分配足够的内存。Python还会自动地向数据类型关联一组方法列表。例如，已经定义的数字型变量a和b“知道”可以对它们进行加减乘以及所有在表1.2中的数学运算。
*>>>import math>>>math.log(2.)>>>dir(math)>>>help(math.log)
*连接了math模块。那math到底是什么？math是计算机中的一个文件，它真正的名字是math.py。.py扩展名代表Python，这种文件中有Python的指令，如变量的定义、函数及其他（用于计算的）指令。具体来说，math.py文件包含了数学函数的定义及计算指令，如sqrt()、log()等等。
在Python中，包含Python指令的文本文件称为模块，需要import指令用在访问外部模块并读取内容的时候。通过这种方式，使用import导入模块后，它里面已经建立好的定义就变得直接可用了，这样可以高效地分享代码，并被不同的程序使用。
*那如何知道math模块中都定义了哪些数学函数呢？一种方法是可以浏览互联网，找到math.py，打开并阅读其内容，另一种是使用dir指令：只有在导入了math模块后才能使用dir(math)指令，否则dir()会不知道它的参数是什么。从而，可以看到一个包含了在math模块中呈现的变量和函数的完整列表：
*还可以通过如下键入得到关于每个函数的简短解释：
**要导入math中的对数函数，我们用了math.log的符号。在Python中，模块名和函数名之间的点有着特殊的作用，点是对象之间“连接”，我们称点右边的对象是点左边对象的属性，所以
math.log*的意思是log对象（一个函数）是math对象（一个模块）的一个属性，也就是说log是math模块的一部分，如果想在导入模块后使用它，就需要用点语法格式来指向它。这在Python中所有情况都适用，只要对象A含有对象B，语法的格式就是A.B，如果B含有C，A含有B，就可以写为A.B.C。
*对象还可以从模块中选择性导入。换句话说你可能只想导入单个对象或少数几个对象而非整个模块内容。如只导入对数函数而不导入整个math模块，可以写为
>>> from math import log*现在导入函数就不用再写math.log了，而直接写作log，当前环境下有哪些函数和变量可以用Python命名空间很好地解释。
*模块中定义的对象名（函数、变量等）的集合称为模块的命名空间，每个模块都有自己的命名空间。比如math模块有pi、sqrt、cos以及很多其他的名称；random模块的命名空间没有上述这些，但是有randomint和random。连Python shell都有自己的命名空间，包含例如print这样的名称。
*
水解ATP中的一个磷酸二酯键会产生-30.5 kJ/mol标准吉布斯自由能（ΔG0）。根据生物化学课本，真正的ΔG值依赖于化合物浓度。
带入数值，我们可以得到第一个程序脚本，如下
>>> ATP = 3.5>>> ADP = 1.8>>> Pi = 5.0>>> R = 0.00831>>> T = 298>>> deltaG0 = -30.5>>>>>> import math>>> deltaG0 + R * T * math.log(ADP * Pi / ATP)
ATP → ADP + Pi
**所有在Python Shell和程序中的Python命令以同样的方式工作；
*你可以用Ctrl-D（Linux，Mac）或Ctrl-Z（Windows）离开命令行；
*Python Shell作为一个便携式计算器非常好用；
*在Python shell中书写多于两行的程序块会很快变得痛苦的；
*你可以书写多余的行，定义一个程序块：
>>>for i in range(3):
… print i,
012
**第一章示例程序deltaG.py
*运行该程序
*Windows下，在IDLE下选EDIT,而后按F5*或在文本终端中（RUN->CMD） ，进入该文件路径(cd ….)
* python deltaG.py
*Linux/Mac*进入该文件路径(cd ….)
* python deltaG.py
**所有的程序文件要用扩展名.py；
*每一行要确切地包含一个命令；
*代码块用缩进标记。代码块需要用四个空格或一个制表符缩进；
*当你要在UNIX下开发时，在每个Python程序的第一行应该是
#!/usr/bin/env python
**编程用文本编辑器必须可以创建文件、写入和存储文件在硬盘中。基本的编辑器的例子，如Notepad++、Vim（http://www.vim.org/）、TextEdit、Pico、Gedit（http://projects.gnome.org/gedit/）等等，其中大部分都能够自动高亮Python代码句法结构。当使用一个正常的编辑器的时候，确保制表符会被自动替换为空格，在Gedit中你可以通过Edit=>Preferences来设置。找到Edit tab并选择“Insert spaces instead of tabs”。* IDLE编辑器（在Windows系统中是已经与Python一起自动安装了的）也可以识别并处理代码块（也就是说处理缩进）。在Linux和Mac OS X中有iPython，这是改进版的Python 是shell，不仅可以提供代码句法高亮，还可以用制表符键自动补全很多函数的代码（详见http://ipyhon.org/）。
** Python还有很多复杂精致的编辑器，也称为集成开发环境或IDEs。首先，可以通过
*这类编辑器将代码调整成统一的格式：加入空格、用不同颜色高亮关键字，标记出缺失的括号，有些IDEs甚至能标出语法错误；编写代码时，可以查找名称或者当前文档；调试时
*不必添加输出语句就可以分步遍历程序、跟踪变量值。比较流行的Python集成开发环境有Eric（Linux）、SPE（Linux）和Sublime Text（Win/Mac/Linux，http://www.sublimetext.com）。
*建议Windows环境下使用PyChrome(https://www.jetbrains.com/pycharm/),
*第二章示例程序count_aminoacids.py
在Python编程语言中，程序会按顺序一行行执行，• #insulin。第一行什么也没做。井号#意味着这是注释（见2.3.3节）• insulin = “MALWM...”。这一行中，序列存储在名为insulin的变量中，序列
定义为文本，也叫字符 串。• for amino_acid。这一语句开始了一个遍历20个字符A、C、D、E……的循环，
对于每一个字符重复接下来两行的指令，amino_acid是代表了每次循环中那一个字符的变量，循环会在变量amino_acid到达“ACD…”的 后一个字符的时候停止。
• number = insulin.count(...) 这一行调用了计算一个字符在一段文本中出现的个数的函数，结果被存在变量中。
• print amino_acid, number 将氨基酸及计数结果打印在屏幕上。后这三行组成了一个代码块。因为有for命令，这意味着它们将一起被执行
20次。与for命令相关联的行，用4个空格的缩进分组在一起
**数据结构
流程控制
*选择结构
*For循环
*While循环
Integers 整型，是小数点后没有数字的数值
Floats 浮点数，是包含小数点后数字的数值
Strings 字符串，是字符的不可改变的有序收集，用单引号（’abc’）或者
双引号（"abc”）标记
Lists 列表，是对象的可变的有序收集，用方括号（[a,b,c]）标记
Tuples 元组，是对象的不可变的有序收集，用圆括号（（a,b,c））标记，
或用逗号列出收集的数据项（a,b,c）Dictionaries 字典，是键值对（key:value）的无序收集
Sets 集合，是唯一元素的收集
Boolean 布尔值，是True或者False。
**Python字符串由单个引号或三个引号（单或双引号均可）,三引号可以包含多行，并作为文档字符串（见函数）。
下面的字符串是等价的：
“This is a string in Python\n”‘This is a string in Python\n’”’This is a string in Python\n”’“””This is a string in Python\n”””*重要的要记住的是，如果一个字符串以一种类型引号开始，就必须用同一类型的引号结束。
*可以给它赋给一个变量，如
>>>s=‘This is a string in Python\n’*转义字符
*打印文本（或将其分配给字符串变量）时，在Python字符串中不能使用每个字符。一些字符需要替换成转义字符。例如，需要将制表符写作\t（用反斜杠）；换行符写作\ n；反斜线写作\\。
*
>>>a=“Hello world”
>>>a[1]
‘e’
>>>a[-1]
‘d’
>>>a[1:3]
‘el’
>>>a[1:]
‘ello world ‘
>>>a[::-1]
'dlrow olleH'
+-----+-----+-----+-----+-----+-----+| P | y | t | h | o | n |+-----+-----+-----+-----+-----+-----+0 1 2 3 4 5 6-6 -5 -4 -3 -2 -1
字符串（序列）位置索引通过方括号内的数字索引，可以提取字
符的某些位置。第一个字符被视为在位置0，负指数应对末尾开始的字符：
切片通过在方括号中引入一个冒号，可以提取部分字符串（切片）。例如[0:3]返回从头开始，第三个字符后停止的子字符串：
[1:]为第一个字符之后开始，停止于字符串的末尾的切片。
第二个冒号后的数字表示步长
*>>>a=“Hello”>>>b=“ World”>>>a + b #字符串相加
>>>a += b #自加链接字符串
>>>a>>>len(a) #内置函数
>>>a.lower() #字符串方法
>>>a[0] = “!” #错误，字符串不可变的
len()函数返回字符串中的字符数的长度：lower方法返回小写字符串。
字符串是不可变的（除了在Python 3中的ByteArray）。一旦创建一个字符串，它不能被修改。
**count(sub[, start[, end]]):计算子串sub出现在开始和结束位置（如果选择的话）之间的次数。让我们看看如何可以用于它来计算序列的CG含量
*replace(old,new[,count]):让我们来用另一部分（new）取代字符串的一部分（old）。如果使用可选参数count，只有 早出现count的old将被替换。
*find(sub[,start[,end]]): 返回开始和结束位置（如果定义了）之间的子串sub的位置。如果子串在字符串没有出现，此方法返回值-1* index(sub[,start[,end]]):和find()方法类似。所不同的是在没有找到子串时，index将引发一个ValueError异常。这种方法是比find()更推荐使用的，因为值-1可以解释为一个有效的值，而index()返回的ValueError错误是不能作为一个有效的值的。
*split([sep [,maxsplit]]): 分隔字符串的“单词”，并返回他们在一个列表中。如果没有指定分隔符（sep），默认的分隔符将是空白
*strip()去除字符串两端的空白字符（包括制表符和换行符）
** 类型转换 str(any_object)转换任意对象到字符串
* 格式化字符串
变量和字符串可以用格式化字符组合在一起，这在print语句内也可使用。
在两种情况下，值和格式化字符的数目必须相同。
>>>s = 'Result:%i‘ % (number)>>>print 'Hello%s!‘ % ('Roger')>>>print '(%6.3f/%6.3f)‘ % (a,b)格式化字符包含如下：
* %i：一个整数
* %4i：一个整数格式化为长度4* %6.2f: 一个浮点数长度为6，小数点后有两位
* %10s：一个右对齐的长度为10的字符串
* 注：Python2.7之后的版本提供了.format()函数，功能更强大。
* 连接字符串
>>>linker=“”>>>inker.join(string_list), # 用linker(可以是任意字符串）连接字符串列表。
** 列表是Python中的主力数据类型
列表是在Python中 多才多艺的对象类型之一。一个列表是一个顺序地收集对象的元素，
它是由逗号分隔的元素用方括号括起来。
我们已经看到应用在split()函数中的结果的列表：
>>> “Alex Doe,5555-2333,[email protected]”.split(“,”)[’Alex Doe’, ’5555-2333’, ’[email protected]’]
这个列表包括三个元素’Alex Doe’, ’5555-2333’ 和’[email protected]’，它们都是字符串。
* 下面的例子是怎样定义和命名字符串：
>>> first_list=[1,2,3,4,5]>>> other_list=[1,"two",3,4,"last"]>>> nested_list=[1,"two",first_list,4,"last"] #一个列表甚至可以包含另一个列表：
>>> nested_list[1, ’two’, [1, 2, 3, 4, 5], 4, ’last’]
* 一个空列表用空方括号表示，空列表它自己没有用途，但有时我们可能要定义一个空列表，以便在以后添加元素
>>> empty_list=[]>>> empty_list[]* 列表初始化
* 如果事先知道，列表将有五项元素，我们可以用默认值初始化它：
>>> codons = [None] * 5>>> codons[None, None, None, None, None]
** 这是另一种方式来定义一个列表，从另一个列表中可以创建一个列表。在数学里，你可以通过枚举其所有元素建立一
个集合（enumeration）或通过描述其所有成员共同享有的性质来创建（comprehension），在Python中的列表被两种方法都能创建。
* 一个通过枚举定义的集合如下
A = {0, 1, 2, 3, 4, 5}* 而通过枚举定义Python的列表为：
>>> A = [0,1,2,3,4,5]* 集合可以由推导式定义：
B = {3 ∗ x/x ∈ A}* 这等价于
B = {0, 3, 6, 9, 12, 15}
* Python列表也可以从推导式得到：
>>> [3*x for x in A][0, 3, 6, 9, 12, 15]* 任何一种Python函数或方法都能够通过推导式法来定义列表：
>>> animals = [’ king kong ’, ’ godzilla ’, ’ gamera ’]>>> [y.strip() for y in animals][’king kong’, ’godzilla’, ’gamera’]* 结果的列表可以被用条件的声明来进行限制：
>>> animals = [’ king kong’, ’ godzilla ’, ’ gamera ’]>>> [y.strip() for y in animals if ’i’ in y][’king kong’, ’godzilla’]
访问列表的元素你可以用方括号来访问一个列表的任意元素。第一个元素的索引是0。
从其他列表创建列表你可以用方括号像在提取子字符串一样提取列表的子列表。
*
data = [1,2,3,4,5] 创建一个列表
data[0] 访问第一个元素
data[3] 访问第四个元素
data[-1] 访问 后一个元素
data[0] = 7 对第一个元素重新赋值
data = [1,2,3,4,5] 创建一个列表
data[1:3] [2,3]
data[0:2] [1,2]
data[:3] [1,2,3]
data[-2:] [4,5]
backup = data[:] 创建该列表的副本
>>> a=[1,2,3]>>> b=a>>> b.pop()3>>> a[1, 2]
>>> a=[1,2,3]>>> b=a[:]>>> b.pop()3>>> a[1, 2, 3]
复制列表如右面方法所示
l[i] = x l 的第i个元素替换为 x
l[i:j] = t l 的第i个元素到第j个元素被替换为t（t是可迭代的）
del l[i:j] 删除l 的第i个元素到第j个元素
l[i:j:k] = t 元素l[i:j:k]被用t中的元素替换（t必须是一个序列，且满足len(l[i:j:k]) = len(t)）
del s[i:j:k] 删除l 的第i个到第j个中步长为k的元素
l.append(x) 与l[len(l):len(l)]=[x]相同。追加元素到列表l中
l.extend(x) 与l[len(l):len(l)]=x相同，这里x是任何可迭代对象。
l.count(x) 计算元素x在l中的个数
l.index(x [, i [, j]]) 返回 小的k值，满足l[k]=x且i≤k≤j
l.insert(I,x) 这和l[i:i]=[x]相同
l.pop(i) 它取消第i个元素，并返回它的值。
l.pop()等价返回l[-1]的值，然后删除列表 后一个字符。
l.remove(x) 与del l[l.index(x)] 相同
l.reverse() 把l的元素反向排列
l.sort() 排序列表l
l.sort([cmp[, key[, reverse ]]])
比较的控制项可以传递给sort( )方法，cmp是定制化的函数来比较元素对，返回负值、零和正值，
返回值依赖该对的第一个元素小于、等于或者大于第二个元素。
sorted(l) 用l的简单的升序排列，创建一个新的列表，而不修改列表l
*修改列表
**用于列表的函数：
data = [3,2,1,5] 示例数据
len(data) data的长度；返回4；对其他许多类型也适用
min(data) data中元素的 小值；返回1max(data) data中元素的 大值；返回5sum(data) 对data中元素求和；返回11range(4) 创建数值的列表；返回[0,1,2,3]range(1,5) 从起始值创建列表；返回[1,2,3,4]range(2,9,2) 用步长创建列表；返回[2,4,6,8]range(5,0,-1) 从起始值反向计数创建列表；返回[5,4,3,2,1]
** 元组的主要特点是，一旦被创建，它就不能被修改。这就是为什么它们被称为“不可改变的列表。”Python对象有时被划分成可变的和不可改变的。顾名思义，不可改变的对象从它们创建后不能被修改。因为元组的元素之间是用圆括号而不是方括号括起来的，你可以轻松地分辨元组和列表：
>>> point=(23,56,11)* point是一个具有三个元素的元组（23，56和11）。
有一个特定的情况下，你应该使用一个逗号，定义一个元素的元组：
one_element_tuple = (5,)* 这样做是为了解决有歧义的（5），它的意思是5（五）周围有括号，周围的括号表达被忽略。加上后面的逗号和括号后，很显然，它是一个元组，而不是一个表达式。
* 你不允许从元组中添加或删除元素：
>>> point.append(3)Traceback (most recent call last):File “<stdin>”, line 1, in ?AttributeError: ’tuple’ object has no attribute ’append’
>>> point.pop()Traceback (most recent call last):File “<stdin>”, line 1, in ?AttributeError: ’tuple’ object has no attribute ’pop’
**作为元组和列表，在数据存储和数据类型之间有一个概念上的差异。
*列表应保存一个可变数目的具有相同数据类型的对象变量。一列包含在目录中的所有文件的文件名可以存储在一个列表中。他们是同一类型（字符串），并随着每个目录的清单中的元素数量而变化。这个列表内的元素顺序是不相关的。
*另一方面，一个典型的元组例子是一个的坐标系。在三维坐标系统中，每个点是由三个元素的元组（X，Y，Z）构成的。每个元组的元素的数量不会改变（因为总有三个坐标），每个位置同等重要，因为每个点对应一个特定的轴。
*元组的另一个优点是它可以被用来书写更安全的代码— 我们不想改变的信息保存在“写保护”的一个不可改变的元组中。
*在某些情况下，元组的处理速度比列表更快。虽然在大多数情况下这是真的，但这不应该是在列表或元组之间进行选择时的主要考虑因素。
*
*共有特征：
*索引
*切片
*成员资格测试 elem in seq
*级联（加法） seq1 + seq2
*函数
* len, max, min
*互相转化
* list, str, tuple
**缩进：在任何一个由冒号（:）结束的语句后，所有缩进的命令是被看作一个代码块，如果条件满足将被循环执行。下一个未缩进的命令被标记为代码块的结束。所谓缩进指的是制表符或若干空格打头的行，同一代码文件缩进必须相同。
*计算一个表达式，如果表达式为真，
在if子句后的代码块被执行，
否则，在else块中执行。
一个if – else条件的基本模式如右
* If必选
* elif，else可选
*关系表达式见下页
*
a == b a等于ba != b a不等于ba < b a小于ba > b a大于ba <= b a小于等于ba >= b a大于等于bin, not in in和not in运算符检查左边的对象是否包含（或不包含）在右边的字符串、
列表或字典中，返回布尔值True或者False。is, is not is和is not运算符检查左边的对象是否与右边的对象一样（或不一样），返
回布尔值True或者False。a and b 布尔运算符：如果两个条件a和b都是True，返回True，否则返回False。a or b 布尔运算符：如果两个条件a和b中至少有一个是True，返回True，否则返
回False。not a 布尔运算符：如果条件a是假，返回True，否则返回False。
关系表达式所有的比较变量其结果是True或者False。
*
for base in ‘AGCT’:print base
打印四行，包括A，G，C和T
for number in range(5):print number
打印五行，数字从0到4
for elem in [1,4,9,16]:print elem
打印四个数值，每个在一行
这种控制结构使代码被重复执行，并同时保有一个可迭代的对象（注： 常见的可迭代的对象是：列表，元组，字符串和字典。文件和定制的对象，也可迭代的。）的值的变量。一个for循环的一般形式如右边：
**这个循环非常类似for循环，因为它也是在以反复的方式执行代码部分。在这里，没有一个迭代的对象，这个循环不会以迭代遍历对象方式结束，而是通过给定一个条件是不真时结束。
*什么是时候用while*当循环有一个退出条件
*当你需要只满足给定条件时开始循环
*当循环可能什么都不做时
*当重复的数目依赖用户的输入时
*当你搜索列表中特定的元素时
**pass 语句
*占位语句，什么都不做。常用于if块，函数，模块之间的占位。
*break 语句
*退出循环。常用于for, while循环。
*continue语句
*继续下一次循环，常用于for, while循环。
*
f = open(‘my_file.txt’)text = f.read()
读取文本文件，把它的内容读入一个字符变量
f = open(‘my_file.txt’,’w’)f.write(text)
创建一个新文本文件，从一个字符串变量写入文本
f = open(‘my_file.txt’,’a’)f.write(text)
追加文本到已经存在的文件中
f.close() 关闭使用后的文件；关闭文件在Python中是一个好风格但不是强制的。
lines = f.readline() 从一个文本文件中读取所有行到一个列表中
f.writelines(lines) 写行的列表到文件中
for line in open(name):print line
遍历所有行，打印每一行
lines = [‘first line\n’, ‘second line\n’]f = open(‘my_file.txt’,’w’)f.writelines(lines)
创建行的列表用行末用换行符，并存入一个文本文件
读取和写入文件文本文件可以通过用open()函数访问，它返回一个打开的文件，其内容可以作为字符串提取或是通过字符串写入。如果你试图打开一个不存在的文件，将创建一个IOError。
*
*当这个语句执行时，EXPRESSION被求值。一种特殊的方法（__enter__）被调用返回EXPRESSION的对象。无论__enter__返回什么值起个名字叫VARIABLE。而后在块中的代码将被执行。当完成的时候（完成块或抛出错误），程序调用__exit__方法。这种方法能处理异常，因此，如果块内有一个内部错误，程序将保证一个特定的代码将被执行。这个代码可用于代码关闭一个打开资源。
*在对象是文件的情况下，它有__enter__和__exit__的方法。__enter__返回文件对象本身，__exit__该文件并退出。如果程序有一个错误出现在打开文件之后，关闭文件之前，数据将丢失，该文件将不能从其他应用程序访问。运用with我们可以确信无论文件中的代码块发生什么事情，文件都将会被关闭。
*
*1，任意输入一DNA文本，存储到变量dna中，计算其GC含量打印到屏幕。
*
*2，从FASTA格式文件输入DNA文本序列，存储到变量dna中，计算其GC含量打印到屏幕。
*https://www.ncbi.nlm.nih.gov/nuccore/1036032746?report=fasta Homo sapiens insulin (INS) gene, complete cds
*保存为insulin.fa
**测定蛋白浓度的数据表。(第七章，
lowry_data.txt)*数据用制符分割文本。
*Protein:浓度和三次实验值，
*想合并成两列。
*很有用的技巧
* zip是链接函数，把两个以上的数据，合成一个表。
* zip(*table)的用法，稍后函数时讲到。
protein ext1 ext2 ext30.16 0.038 0.044 0.040.33 0.089 0.095 0.0910.66 0.184 0.191 0.191
1 0.28 0.292 0.2831.32 0.365 0.367 0.3651.66 0.441 0.443 0.444
**测定蛋白浓度的数据表。(第七章，lowry_data.txt)
*用列表排序的方法，可以对
表进行排序。
这里key=是sort的参数，指明要
排序的键，是一个函数的对象。
lamda x：是匿名函数，仅返回
一个表达式，这里x是列表每项
的值，x[0]是protein,由于是字
符串型，需要转换成float。
** 字典为键（key）: 值（value） 对的对象的无序集合，用花括号括起来：{'GCU': 'A', 'GCC': 'A'}。更特别的是，字典是不可变对象（键）映射任意对象（值）的结构。不可变对象可以是数字，字符串和元组。这意味着，列表和字典本身不能用作字典键，但能被用作值。
* 键和它的值之间由冒号进行分隔，键:值对之间用逗号进行分隔。
* dict还允许在参数列表中用name=value对的方法创建：
* >>> rgb = dict(red=’ff0000’,green=’00ff00’,blue=’0000ff’)* >>> rgb* {’blue’: ’0000ff’, ’green’: ’00ff00’, ’red’: ’ff0000’}* 初始化一个字典的另一种方法是创建一个空的字典，并根据需要添加元素：
* >>> rgb = {}* >>> rgb[’red’] = ’ff0000’
* 字典可以被用来快速查找，其常用方法如下：
访问字典中的数据用方括号来包含一个键，你可以请求字典的该值。键可以是字符串，整型，浮点型和元组。
prices[‘banana’] 返回’banana’对应的值（0.75）prices.get(‘banana’) 返回’banana’对应的值，但是防止KeyError。如果键不存在，将返回Noneprices.has_key(‘apple’) 检查’apple’是否被定义
prices.keys() 返回所有键的列表
pricies.values() 返回所有值的列表
prices.items() 返回一个元组的列表，包含键和值
*len(a） a的元素数量
a[k] 在a具有k键的元素
a[k]= v 设置a[k]的值为vdel a[k] 从a中删除a[k]a.clear() 移除a中所有项目
a.copy() a的一个副本
k in a 如果k是a的一个键，返回
True，否则返回Falsek not in a 等效于not k in aa.has_key(k) 相当于k in a，在新代码中
使用
a.items() （键，值）对列表的副本
a.keys() a的键列表的副本
a.update([b]) 从b中更新（和覆盖）的键/值对
a.fromkeys(seq,[value]) 创建新的字典，并用seq作键的集合，value作值
a.values() a值的列表的副本
a.get(k[，x]) 如果k在a中返回a[K]，否则返回x
a.setdefault（k[，x]） 如果k在a中返回a[K]，否则返回x（同时设置它的值）
a.pop(k [，x]) 如果k在a中返回a[K]，否则返回x（同时删除k的值）
a.popitem() 移除并返回任意一个（键，值）对
**集合是与字典类似的数据结构。类似数学中的集合概念，其元素也必须是不可变类型。集合 常见的用途是成员测试，重复删除，以及数学运算的应用：交(intersection)，并（union)，差(difference)，和对称差（symmetrical difference)。
*创建一个集合
*集合是通过指令set()创建的
>>> first_set = set([’CP0140.1’,’EF3613.1’,’EF3616.1’])
*也可以创建一个空集合，然后根据需要添加元素：
>>> first_set = set()
>>> first_set.add(’CP0140.1’)
。。。
*A = set([1,2,3,4]), B=set([2,3,4,5])
*交集
>>> A & Bset([2,3,4])*并集
>>> A | Bset([1,2,3,4,5])*差>>> A - Bset([1])*对称差
>>> A ^ Bset([1,5])
**第五章
*translate_rna.py
*利用了编码子的字典，查找对应的氨基酸
*考虑三个开放阅读窗
*编码子用列表切片得到
* 有一段代码，是格式化48单位长度输出
*
数据结构
运算符
流程控制
模块
类
函数
Python保留字
**函数的一般定义如下
*FunctionName是函数名，与变量名定义规则相同。
*Arguments是函数参数
*三引号称文档字符，是函数引用帮助，用__doc__的属性可以获取，在help(函数名）时显示
*return是返回语句，可以没有（这时函数完成返回None）或 多个。也可无返回值（None），或返回多个逗号分隔的值（元组）。
*如定义一个相加的函数如下
** 必选参数：一个或多个参数必须传递给函数。参数在调用中的顺序必须与函数定义中的顺序完全一致
def addtion(num1,num2):….
* 关键字参数：可以向函数参数分配一个名称。在这种情况下，顺序不重要:调用如addtion(num1=1,num2=2)
* 默认参数：还可以使用默认可选参数。这些可选参数必须放在函数定义的 后位置。
def addtion(num1,num2=2):….
* 默认参数应该始终为不可变类型(即数字、字符串)。千万不要使用列表或字典作为默认参数,否则会导致非常严重的错误。
* 变长参数：参数的个数是可变的（即可以
* 从一个函数调用切换到另一个函数调用）；
* 参数由符号*（对元组）或**（对字典）表示。
* 当使用* *符号时，你必须提供返回字典的关键字和值:
* 在这里,函数调用打印出了一个字典：
**当一个函数被调用时，会自动创建一个本地命名空间。函数体内定义的变量位于其本地命名空间内。而不在脚本或模块的全局命名空间内。当一个函数被调用时，首先会在函数命名空间内搜索函数体内的对象名称，如果未在函数体内找到对象名称，那么然后就会在脚本或模块的全局命名空间内进行搜索。
在Python中，有很多对象（模块、函数、类）是预先定义的。有些在调用Python解释器时会自动导入。这些对象称为“内置函数”。例如，从来不需导入函数len()、sum()和range()（参见专题10.3）。在使用字符串时，也是隐式地使用内置对象“str”（即不需要定义什么是字符串）；列表、字典和数字亦是如此。一般来说，每当不用定义便可使用某个对象时，就意味着在使用内嵌对象。可参见
附录A“命令概览”中列举的Python内嵌函数的表。
*
每个函数应该只有一个目标函数名应该清晰，用单词打头在函数起始位置，应该有一个三引号的注释（一个文档字符串）函数应该只用一种方式返回结果函数应该短小（小于100行）
*
**迭代器（Iterator）是一种特殊的函数。函数执行一些操作，然后其结果返回到它被调用的点。它就像一个批处理执行直到完成的过程。如果函数的结果是一个很大的对象（像一个大的列表，元组，集合，文件等），这可能会导致问题，如系统的不稳定。
*例如，用一个函数从文件中读取记录，并返回一个从这个文件中的数据得到的数据结构。如果文件太大（如几倍的可用内存），由此产生的数据结构可能不适合在内存中。如果想法是处理每个记录，我们需要一个函数，返回次数的记录。函数不能做到这一点，因为它不保持状态，所以每次执行时，它再次处理所有数据。发生器可以被定义为函数，但它可以保持其内部状态。他们引入了一个新的关键字：yield。当yield VALUE语句被发现时，它返回（或出产）一个值返回到调用它的地方（类似函数），但保留其内部值的轨迹，因此它被下一次调用时，它从前面出产值的地方恢复运行。
**类是真实或虚构事物的抽象表示。类定义了其所代表的事情将如何表现，但它不包含任何特定的数据。具体数据在对象中，而对象从类中生成，称作实例。
类以属性的形式包含数据
类包含的方法
使用类有助于把握复杂程序
**进一步更改前面的GC含量程序,输入文件到一个seq类的实例中。计算gc含量函数从另一模块gcbase中导入。
*也可以试着把写一个子类的方法get_gc（作业）
**程序错误：
*语法错误，
*容易
*由编辑器或错误信息定位。错误在所示行，或前面行。
*运行时报错
*较易
*根据错误类型，对相关数据进行检查
*逻辑错误
*较难
*用插入print语句的方法，逐步定义错误。或者用DEBUG程序跟踪。
*作业
* 第十二章示例错误程序调试
** try...except语句可以在程序中止前捕获到程序错误。预计运行时错误的语句集合插入在以try开始的缩进代码块中，而对错误作出反应的语句插入在以except开始的缩进代码块中。try...except语句通过在except语句中指定要处理的异常类型来处理异常。例如，可以使用except语句作用于特定的错误类型：
即使程序被谨慎地书写，这些还会出现错误，需要化精力截获它们。比如
*文件操作
*网络操作
*数据库操作
*用户输入，特别是数值
当然把整个程序嵌入一个单个的try…except子句中是可以的，但是这经常每什么意义，因为如此的代码就不透明，也更难调试。
**《编程的准则》：
*首先，让程序运行。
*其次，完善程序。
* 后，在确有必要的情况下，提高程序的速度。
*1 将编程项目分成小任务
*2 将程序分为函数和类
*3 编写格式良好的代码
*应该在逗号和算术运算符后面添加一个空格。
*函数中的变量名称应该小写。
*模块中的常量名称应该大写。
*每个函数后面应该空两行。
*每个函数都应该有文档注释字符串。
*4 使用存储库控制程序版本
**Python除了内置函数外，提供了上千个标准模块，是开发者提供的 常用的功能。前面我们提到的math模块就是标准模块之一。这些模块被安装在系统中，用import语句进行调用，下面介绍几个 有用的标准模块。
*re：正则表达式模块
*sys：系统模块
*os，os.path：操作系统模块
*random: 随机数产生模块
*time，date：时间日期模块
*subprocess:调用系统命令模块
*pdb：程序调试
*。。。。
**正则表达式可以实现字符串的模式匹配，以及用精致的方式搜索和替换文本：
*序列功能模体（sequence functional motif）寻找
*数据按格式解析
*正则表达式（regular expressions），有时也被称为regexp，是能代表一组字符串的字符串语法，由字符以及元字符组成。换句话说，如果你想用一串字符表达几个字符串，就有必要引入新的规则，使得可以允许“多元”含义存在，如通配符，重复字符或逻辑组。
*一个经常在生物学中使用的例子就是DNA序列字符N。序列AGNNT可能是AGAAT，AGCTT，AGGGT，或许多其他的可能性之一。正则表达式以类似的方式工作，但使用更复杂的特殊字符集
*>>>import re>>>text = 'all ways lead to Rome‘*搜索文本是否存在
>>>m=re.search('R...’, text)*找到所有匹配子串
>>>re.findall('\s(.o)', text)*替换给定模式成新字符串
>>>re.sub('R[meo]+','London', text)
*模式编译
>>>pattern = re.compile(“R…\s”,re.IGNORECASE)>>>m = pattern.search(text)
练习正则表达式的网站，在写入re前，在此测试
http://www.regexplanet.com/advanced/python/index.html
** []括号用来指示一类的字符。例如，如果搜索字符串s中[ABC]的匹配，你会发现，如果s包含'A'，'B'或'C'，字符都能被发现。
特别是[a-z]匹配从a到z的字母字符，而[0-9]匹配0至9之间的整数。
* ^[^ a]表示除了a以外的字符。
^a（不包含在方括号）表示只匹配是s在第一个位置的情况。
* $一个$表示匹配是s在 后一个位置的情况。
* \\的含义取决于\后面跟随元字符还是字符。在前面一种情况下，\“保护”元字符并恢复其字面意义；在第二种情况下，它的含义取决于该字符。
* \ d对应于[0-9];* \ D对应于[^ 0-9];* \ s对应于[\ t \n\ r \ f \ v]，即任何空白字符
* \ S对应于[^ \ t \n\ r \ f \ v]，即任何非空字符
* \ w相当于[a-zA-Z0-9]，即任何字母数字字符
* \ W对应于[^ a-zA-Z0-9]，即任何非字母数字字符。
* .
这相当于除换行符外的任何字符。
* |
这是OR运算。如果放置两个正则表达式之间，匹配
将被搜索或者符合其左侧的正则表达式或符合另一半正则表达式的结果。
* ( )
圆括号用于在正则表达式中创建子组。
*
重复：* + ? { }这些元字符用于查找与重复的东西相匹配的结果。
* *
可以被匹配零次或多次。a*bc可以匹配bc”， “abc” ，“aabc” ，“aaabc” ，“aaaabc”* +
可以被匹配的一个或更多次。a+bc 可以匹配 “abc” ，“aabc” ，“aaabc” ，“aaaabc”， 等，但不能匹配“bc”。* ？
可以匹配零次或一次。can-?can可以匹配 “can-can” 和 “cancan”。* {m,n}
该限定符意味着至少m至多n个重复可以被匹配。
*方法 返回对象 归属于 功能
compile() Regex对象 编译一个正则表达式（RE）match() Match对象 Regex对象 决定该RE是否从字符串的开头匹配
search() Match对象 Regex对象 扫描字符串，寻找任何RE匹配的位置
findall() 列表 Regex对象 找到所有RE匹配的子串并返回它们的列表
finditer() 迭代器对象 Regex对象 找到所有RE匹配的子串并返回它们的迭代器
span() 元组 Match对象 返回一个元组包含匹配的（起始，终止）位置
start() 整型 Match对象 返回匹配的起始位置
end() 整型 Match对象 返回匹配的终止位置
group() 字符串 Match对象 返回RE的匹配字符串
groups() 元组 Match对象 返回一个元组，包含所有子组的字符串
split(s) 列表 Regex对象 把字符串分割成列表，用RE匹配进行分割
sub(r, s) 字符串 Regex对象 找到所有RE匹配的子串，把它们替换成不同的字
符串
subn(r, s) 元组 Regex对象 与sub()作同样的事，返回新字符串和替换的数目
*正则表达式编译标志
标志 功能
DOTALL, S 使得点（.）匹配任何字符，包括换行符
IGNORECASE, I 做大小写不敏感的匹配
LOCALE, L 做本地化识别匹配，也就是采用本地系统的C库（例
如，支持其它语言）
MULTILINE, M 做多行匹配，影响^和$:^（$）匹配字符串中每行的
开始（结束）
VERBOSE, V 使用冗余的RE，它可以组织得更整洁和易懂，即允
许书写的RE更具有可读性，如引入空格和注释
你可以在re.compile中用加入参数的方式定制模式匹配。例如，如果你需要实现大小写不敏感的搜索，可以加入re.IGNORECASE到re.compile()参数中。这是一个你能定制搜索用的可能列表：
*
*用sys.argv 可以传递系统命令行参数。见如下程序
*这里的if语句是固定用法，用于一个模块脚本的底部，仅在命令行执行该脚本时，执行if块中的内容；而在import该模块，则不会执行if块。
*sys.argv收集包含脚本名的命令行参数，脚本名是第一个，所以参数从1开始。
** Python os模块包含普遍的操作系统功能。如果你希望你的程序能够与平台无关的话，这个模块是尤为重要的。即它允许一个程序在编写后不需要任何改动，也不会发生任何问题，就可以在Linux和Windows下运行。
* 下面列出了一些在Python os模块中比较有用的部分。它们中的大多数都简单明了。
* os.listdir(dirname)：列出dirname下的目录和文件
* os.getcwd()：获得当前工作目录
* os.curdir:返回但前目录（'.')* os.chdir(dirname):改变工作目录到dirname* os.path.isdir(name):判断name是不是一个目录，name不是目录就返回false* os.path.isfile(name):判断name是不是一个文件，不存在name也返回false* os.path.exists(name):判断是否存在文件或目录name* os.path.getsize(name):获得文件大小，如果name是目录返回0L* os.path.abspath(name):获得绝对路径
* os.path.normpath(ppath):规范path字符串形式
* os.path.split(name):分割文件名与目录（事实上，如果你完全使用目录，它也会将 后一个目录作为文件名而分离，同时它不会判断文件或目录是否存在）
* os.path.splitext():分离文件名与扩展名
* os.path.join(path,name):连接目录与文件名或目录
* os.path.basename(path):返回文件名
* os.path.dirname(path):返回文件路径
* 特别地， os.system可以调用系统命令行。 这个命令有助于搭建pipeline,见书第十四章。
*https://docs.python.org/2/library/random.html
按上面文档学习random函数用法。
按下列三种情况产生DNA随机序列
1, 写函数rand_seq_choice(length), 等概率产生长度为length的DNA随机序列，返回该序列的字符串。
2,写函数rand_seq_shuffle(old_seq),按给定序列的频率，产生长度相同的DNA随机序列，返回该序列的字符串。
3,写函数rand_seq_gc(gc_content,length）按给定序列的gc_content，产生长度length的DNA随机序列，返回该序列的字符串。(G/C等概率）
**Biopython
pip install biopython
Windows（C:\python27\Scripts\pip install biopython)
OR
http://biopython.org/wiki/Download
*matplotlib
pip install matplotlib
Windows（C:\python27\Scripts\pip install matplotlib)
OR
http://matplotlib.org/users/installing.html
**Biopython (http://biopython.org/wiki/Main_Page )是一个计算分子生物学模块的集合，用它可以实现许多生物信息学项目中需要的基本任务。
*用Biopython可以实现的 常用的任务包括：
*解析（也就是说提取信息）文件格式，这些信息如包含基因和蛋白质序列、蛋白质结构、PubMed记录等；
*从资源库下载文件，这些资源库包括NCBI，ExPASy等；
*运行（本地或远程）常用生物信息算法，如BLAST，ClustalW等；
*运行Biopython实现的算法，进行聚类、机器学习、数据分析和可视化。
*它也提供了用户能用来处理数据（如序列）的类和操作它们的方法（如翻译、互补） 。Biopython Tutorial and Cookbook (http://biopython.org/DIST/docs/tutorial/Tutorial.html)是用来掌握Biopython可以为用户做什么的好的起点。更多的高级教程可以从特别的包中获得：(如, “The Biopython Structural Bioinformatics FAQ,” http://biopython.org/DIST/docs/cookbook/biopdb_faq.pdf
*当管理生物数据时，要想到Biopython，看看它有没有可用的工具；
*浏览文档，开始熟悉它们的功用；
*用help()，type()，dir()和其它的内置特性来浏览Biopython模块。
*在下面的情况下，书写自己的代码：
*感兴趣算法的实现和编码；
* Biopython的数据结构映射对用户的任务太复杂了；
* Biopython没有提供用户的特别任务的工具；
*用户需要细致控制自己的代码。
*如下情况，用Biopython:*它的模块和/或方法适合用户需要；
*任务没有挑战性或者比较繁琐（如，你为什么要浪费时间？别“重复发明轮子”除非这是你在学习中做练习）；
*任务可能花费用户很多书写的力气。
*扩展Biopython （不推荐）
* Biopython的模块和/或方法总是做你需要的事情，却不能完全满足你的需要；
*必须说明的是，这对初学者来说是一个挑战。阅读和理解别人的代码是困难的。
*
*
**前面例子 用Biopython (第19章）
包括打开序列文件，转录， 翻译，和用FASTA格式输出结果
**它是Bio库中的一个模块。Seq.Seq类创建了一个sequence对象，也就是与一种对象中存储的特定序列字符集的属性相关联的序列。用户可以指定（或不指定）其字符集创建Seq对象：
*Biopython包含了一个预编译好的字符集覆盖了所有生物序列类型。IUPAC定义的字符集（http://www.chem.qmw.ac.uk/iupac）被 频繁地使用。如果用户需要用字符集，就必须从Bio.Alphabet模块（见19.2.2节）导入IUPAC模块。它包括字符集* IUPACUnamiguousDNA（基本的ACTG字母）
* IUPACAmbiguousDNA(包含二义字母)，* ExtendedIUPACDNA(包含修饰的碱基)，* IUPACUnamiguousRNA，* IUPACAmbiguousRNA，* ExtendedIUPACRNA，* IUPACProtein（IUPAC标准氨基酸
* ExtendedIUPACProtein（包括硒代半胱氨酸，X等）。
在19.2.2节定义的dna变量是一个以IUPAC.unambiguous_dna字符集为特征的序列对象。
** transcribe方法只是把所有T替换成U，同时把字符集设置成RNA
mrna = dna.transcribe()*它假定输入DNA序列是编码链。如果你拥有一条模板链，而要完成转录，就需要首先得到一个反向互补链，然后再转录：
>>> dna.reverse_complement()Seq('TTAACGGTATTTGGAGGTCAGCACGGTGCTCACAGAAGCCAGGAACTTGTCCAG...CAT', IUPACUnambiguousDNA())*翻译的密码子表 （一般用Standard,也提供线粒体密码子表等）
>>>from Bio.Data import CodonTable>>> standard_table = CodonTable.unambiguous_dna_by_name["Standard"]可以看这个表
>>>standard_table.forward_table>>>standard_table.start_codons>>>standard_table.stop_codons后用translate翻译序列需要密码子表
mrna.translate(table = "Standard")Or mrna.translate(table = "Vertebrate Mitochondrial")
** Seq对象的行为与Python的字符串类似，就是说它是不可变的。因此，如果试图重新定义序列对象中的一个残基，将得到一个错误信息。这时可以用MutableSeq:
>>> my_seq = \... Seq.MutableSeq("AGCATCGTAGCATG", IUPAC.unambiguous_dna)>>> my_seq[5] = "T">>> my_seqMutableSeq('AGCATTGTAGCATG', IUPACUnambiguousDNA())* 不能用 reverse()或是 remove()方法作用于Seq对象，但是可以用在MutableSeq对象中。
* 后，转换一个不可变的Seq对象到可变的对象，或者反之，都是可能的：要用到Seq对象的tomutable()方法，或是MutableSeq对象的toseq()方法：
>>> my_mut_seq = my_seq.tomutable()>>> my_mut_seqMutableSeq('AGCATCGTAGCATGCAC', IUPACUnambiguousDNA())>>> my_seq = my_mut_seq.toseq()>>> my_seqSeq('AGCATCGTAGCATGCAC', IUPACUnambiguousDNA())
** SeqRecord类提供序列和它注释的容器。在19.2.2节的Python会话中，蛋白质序列在protein_seq变量中，从mRNA序列对象翻译中得到，它可以转换成SeqRecord对象：
*注释包含：
* seq：是一条生物序列，典型的是一个Seq对象形式的数据；
* id: 是基本的ID用来标示这条序列；
* name: 是一个“常用”的分子的名称；
* description: 是序列分子的描述；
* letter_annotation: 是一个用来给每个残基注释的字典。键是注释的类型（如，”secondary structure”）；值是Python序列类型（列表，元祖或字符串），它与这条序列同长，每个元素对应每个残基的注释（如，二级结构类型用单个字符标明，S表折叠，H表螺旋等）。这种表达很容易给残基赋予质量得分、二级结构或访问偏好等；
* annotations: 是一个关于序列的附加信息的字典。键是信息的类型，值包含了信息；
* features: 是一个SeqFeature对象的列表，有更多的关于序列特征的结构信息（如基因组上基因的位置，或是结构域在蛋白质上的位置）；
* dbxrefs: 是一个数据库交叉引用的列表
* SeqRecord支持注释的同步切片功能。
** Biopython的SeqIO模块提供了多种常用文件格式解析器。这些解析器从一个输入文件（或者从本地，或者从数据库中）提取信息，而后自动转换成SeqRecord对象。SeqIO也提供了一种方法来把SeqRecord对象写入到方便的格式化的文件中。
*解析文件
*序列文件解析有两种方法：SeqIO.parse()和SeqIO.read()：两个方法都有两个强制性的参数和一个可选择的参数：
一个文件（强制性；也被叫做“句柄”对象），它指定从哪里读取数据（可以是一个文件名，一个打开的文件，从数据库中用脚本下载的数据，或是另一个脚本片断的输出。）;
一个字符串指示数据的格式（强制性；如 “fasta”或“genbank”；完整的被支持格式的列表在http://biopython.org/wiki/SeqIO ）;
一个参数指定序列数据的字符集（可选择）；
* SeqIO.write()方法写入一个或多个SeqRecord对象到用户指定格式的文件中。这个方法需要三个参数：一个或多个SeqRecord对象，一个句柄对象（也就是一个用“w”模式打开的文件）或是一个文件名，还有一个序列格式(如“fasta”或“genbank”)。第一个参数可以是一个列表，迭代器或是一个单独的SeqRecord对象（如19.2.2节
所示）。当写GenBank文件时，序列的字符集必须被设置。
**第19章示例程序
*-----------------------------------------------------------------*简单的通用过滤器
*NCBI数据库有在线获取功能，Biopython类似的提供了Entrez模块
* 在PubMed中搜索论文
* http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=pubmed&term=thermophilic,packing&rettype=uilist* 检索Medline格式的发表记录
* http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=pubmed&id=11748933,11700088&retmode=text&rettype=medline* 用关键词搜索蛋白质数据库条目
* http://eutils.ncbi.nlm.nih.gov/entrez/eutils/esearch.fcgi?db=protein&term=cancer+AND+human* 用FASTA格式检索蛋白质数据库条目
* http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=protein&id=1234567&rettype=fasta* 用GenBank格式检索蛋白质数据库条目
* http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=protein&id=1234567&rettype=gb* 检索核酸数据库条目
* http://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=nucleotide&id=9790228&rettype=gb
*
*第20章示例程序
*esearch按给定关键字搜索id列表
*read函数解析网络返回结果
*取头三个
*efetch从网上取回数据，
*数据是genbank格式的字典
**为什么用脚本绘图？
*数据多样化，图的格式相对固定。
*便于发表图表时的改动
*保存脚本，比保存操作结果容易
*同时化成百的图
*为什么matplotlib? http://matplotlib.org/gallery.html*Matplotlib = MatLab style plot library
*漂亮
*易用
*强大
*表16.1 23S核糖体亚基的核酸数目。
物种 A C G UT. thermophiles 606 759 1024 398E. coli 762 639 912 591
第16章barplot.py试试改改颜色:red,blue?
**第16章plot_function.py
试试把savefig改成show函数？“kd”改成”b”呢？
**第16章piechart.py
*四个百分号分别是什么意思？
**第16章errorbars.py
给轴添加说明文字？
**第16章histogram.py
*Python for Bioinformatics 为生物信息学设计的Python教程
*http://blog.sciencenet.cn/blog-565112-510336.html
*ChinaUnix论坛Python版
*http://bbs.chinaunix.net/forum-55-1.html