第四章 字符串和序列

在本章中，你将开始编写操作生物序列数据（DNA和蛋白质）的Python程序。以下是你将编写的执行程序：

将DNA转录为RNA

连接序列

获取反向互补序列

从文件中读取序列数据

此外，你还将编写序列信息相关的程序，如DNA序列中GC含量，蛋白质中疏水氨基酸个数等。

你将在本章中学习Python编程技巧及该编程语言的基础知识。以下是一些基础知识：

常量和变量

数组变量

字符串操作，例如替换和翻译

从文件中读取数据

1. 序列数据

本书的大部分内容涉及操作DNA和蛋白质序列的符号，生物信息学中使用了统一的符号表示这些序列符号。

如前所述，DNA由四个构建组成：核酸，也称为核苷酸或碱基。蛋白质由20个结构单位（氨基酸，也称残基）组成，蛋白质片段被称为肽。DNA和蛋白质基本上都是由结构单位首尾相连构建的聚合物，因此，可以通过碱基/氨基酸序列推测DNA/蛋白质分子的结构。

为方便起见，核酸和氨基酸的名称通常表示为单字母或三字母代码，如表4-1和表4-2所示。 （本专辑主要使用单字母表示氨基酸。）

表4-1 标准IUB / IUPAC核酸字母

表4-2 标准IUB / IUPAC氨基酸字母

表4-1中包含了四种基本核酸字母和简并碱基字母，在本专辑的大多数情况下，我们只使用A、C、G、T、U和N。字母A、C、G和T代表DNA中四种碱基，当DNA转录成RNA时，U取代字母T。N表示“未知”的碱基，是测序仪无法确定的碱基。稍后，在第九章中，我们在编写限制性酶切位点需要使用其它用于核酸的字母。注意，在DNA中，这些字母小写版本表示同样的意思。

表4-1和表4-2中的字母在计算机术语和生物学术语中略有不同，在计算机术语中，这些表定义了两个字母表，即可以制作字符串的有限符号集，由字母组成的序列称为字符串。例如，句子是一个字符串，语言是一组（有限或无限）字符串。在本专辑中，语言主要是DNA和蛋白质序列，生物信息学家将之称为“字符串”而不是序列数据。这是计算机术语和生物学术语相互交叉的一个例子。

我们将数据表示为如上所写的简单字母，但计算机实际上使用其它字母来表示简单地字母。记住，使用文本编辑器时用ASCII或纯文本方式保存数据。

ASCII是计算机在其内存中储存文本（和控制）数据的一种方式。然后当诸如文本编辑器的程序读取ASCII数据时，它实际上以可识别的方式在屏幕上绘制出字母。ASCII是代表计算机上文本的代码。

　　2.存储DNA序列的程序

让我们编写一个小程序，将一些DNA储存在变量中并将其打印到屏幕上。DNA由字母A、C、G和T组成，我们称之为变量DNA。换句话说，DNA是程序中使用的DNA序列数据的名称。注意，在Python中，变量实际上是你要使用的某些数据的名称，该名称使你可以完全访问数据。例4-1显示了整个程序。

例子4-1 将DNA打印到屏幕

#!/usr/bin/env python# Storing DNA in a variable, and printing it out# First we store the DNA in a variable called DNADNA = 'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'# Next, we print the DNA onto the screenprint(DNA)# Finally, we'll specifically tell the program to exit.exit()

使用第二章中学习的有关文本编辑器及运行Perl程序的知识，将代码输入（或从专辑的网站上复制）并保存到文件中。记住将程序保存为ASCII或纯文本格式，否则Python解释器可能无法读取文件。

第二步是运行程序，假设程序在你的计算机上，名为example4-1.py。根据第二章内容，在dos窗口中键入以下内容（注意，要切换到文件的储存路径下）：

python example4-1.py

如果您已成功运行该程序，您将看到计算机屏幕上打印的输出。

2.1 控制流程

例子4-1阐明了我们所有Python程序将依赖的许多想法，其中一个想法是控制流程，或程序中语句由计算机执行的顺序。

每个程序从第一行开始并一个接一个地执行语句，直到它结束，除非明确告知程序不这样运行。例子4-1简单地从上到下运行，没有转折。在后面的章节中，你将学习程序如何控制执行流程。

2.1 重新评论

现在让我们看一下例子4-1代码，你会注意到很多空白行让人容易阅读，以“#”开头是注释。当Python运行时，注释与空白行都会忽略。事实上，以下是与例子4-1完全相同的程序：

#!/usr/bin/env pythonDNA = 'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'; print(DNA); exit();

在例子4-1中，我们自由使用了注释，代码开头的注释可以清楚地表明程序的用途、编写者以及在有人需要理解代码时提供其他有用的信息。注释还解释了代码每个部分的用途，如何实现其目标。

关于注释的重要性，很容易理解这一点。我只想说，在大多数大学水平的计算机科学课程课业中，没有注释的程序通常会获得较低或不及格的成绩。另外，工作中没有注释的程序员可能会有短暂而不成功的职业。

2.3 命令解释

程序第一行以“#”开头，看起来像是注释，但它似乎不是一个非常有用的注释：

#!/usr/bin/env python

这是一个称为命令解释的特殊航，告诉Unix和Linux计算机这是一个python程序。在不同的计算机中看起来可能略有不同，也是不必要的，因为计算机从其它信息中识别Python。Windows机器通常配置为假定以.py结尾的任何程序都是python程序。在Windows命令窗口或Unix/Linux、MacOS X shell中，键入python my_program，my_program程序将不需要该特殊行。

2.4 声明

例子4-1的下一行将DNA储存在变量中：

DNA = 'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'

这行代码称为语句，更准确的说，是赋值语句，目的是将一些DNA储存到一个名为DNA的变量中。

2.4.1 变量

首先，让我们看看变量DNA，你可以选择另一个名称进行赋值，程序的运行方式相同。例如，如果你替换两行：

DNA = 'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'print(DNA)

为以下代码：

A_poem_by_Seamus_Heaney = 'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'print(A_poem_by_Seamus_Heaney )

程序以完全相同的方式运行，将DNA打印到计算机屏幕，关键是计算机中的变量名称由你定义（在Python中，变量名必须由大/小写字母、数字和下划线组成，第一个字符不能是数字）。变量名对计算机没有任何意义，但一个有意义的变量名简化了理解程序的繁琐工作，减少代码注释。

在Python中的变量赋值不需要类型声明，每个变量在内存中创建，都包括变量的标识，名称和数据这些信息。

2.4.2 字符串

在例子4-1中，变量DNA保存了用字母A、C、G和T表示的DNA，如前所述，在计算机科学中，一系列字母称为字符串。在Python中，你可以通过将其放在引号中来指定字符串，可以使用单引号、双引号或三引号。DNA因此表示为：

'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'2.4.3 赋值

在Python中，使用“=”符号将变量设置为某个值。“=”符号称为赋值运算符，在例子4-1中，值为：

'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'

被赋值给变量DNA。赋值后，你可以通过变量名称来获取值，如示例4-1中的print语句所示。

赋值语句中，变量在赋值运算符左侧，分配给变量的值在赋值运算符右侧。在编程手册中，有时会遇到lvalue和rvalue这两个术语来指代赋值运算符的左侧和右侧。“=”符号的使用在编程语言中有很长的历史，然而在数学中，使用“=”意味着符号两侧的东西是相等的。因此，要特别注意在Python中，“=”符号并不意味着相等，而是赋值（稍后，我们将看到Python中如何表示平等）。

2.4.4 打印

print(DNA)

该声明将ACGGGAGGACGGGAAAATTACTACGGCATTAGC打印到计算机屏幕。注意，print语句打印变量DNA储存的字符串值，以后你将看到有关打印的更多信息。

2.4.5 退出

最后，声明退出，告诉计算机退出程序。Python在程序结束时不需要退出语句，程序会自动退出。但是放入一个并没有坏处，它清楚地表明程序结束了。

　　3. 连接DNA片段

现在我们将对例子4-1进行简单的修改，以显示如何连接两个DNA片段。 连接是将某些东西附加到其他东西的末尾。 生物学家很清楚，连接DNA序列是生物学实验室中的常见任务，例如当将克隆片段插入细胞载体或在基因表达过程中将外显子拼接在一起时。 许多生物信息学软件包必须处理这些操作;。例4-2演示了一些与字符串，变量和print语句有关的事情。

例子4-2 连接DNA

#!/usr/bin/env python# Concatenating DNA# Store two DNA fragments into two variables called DNA1 and DNA2DNA1 = 'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'DNA2 = 'ATAGTGCCGTGAGAGTGATGTAGTA'# Print the DNA onto the screenprint("Here are the original two DNA fragments:\n\n")print(DNA1, "\n")print(DNA2, "\n\n")# Concatenate the DNA fragments into a third variable and print them# Using "% format"DNA3 = "%s%s" % (DNA1, DNA2)print("Here is the concatenation of the first two fragments (version 1):\n\n")print("%s\n\n" % DNA3)# An alternative way using the "add operator":# Concatenate the DNA fragments into a third variable and print themDNA3 = DNA1 + DNA2print("Here is the concatenation of the first two fragments (version 2):\n\n")print("%s\n\n" % DNA3)# Print the same thing without using the variable DNA3print("Here is the concatenation of the first two fragments (version 3):\n\n")print(DNA1, DNA2, "\n", sep='')exit()

如你所见，这里有三个变量，DNA1、DNA2和DNA3，我们已经为正在运行的评论添加了打印语句，因此计算机屏幕上显示的程序输出更有意义，而不是一个接一个的DNA片段。以下是示例4-2的输出结果：

Here are the original two DNA fragments:ACGGGAGGACGGGAAAATTACTACGGCATTAGCATAGTGCCGTGAGAGTGATGTAGTAHere is the concatenation of the first two fragments (version 1):ACGGGAGGACGGGAAAATTACTACGGCATTAGCATAGTGCCGTGAGAGTGATGTAGTAHere is the concatenation of the first two fragments (version 2):ACGGGAGGACGGGAAAATTACTACGGCATTAGCATAGTGCCGTGAGAGTGATGTAGTAHere is the concatenation of the first two fragments (version 3):ACGGGAGGACGGGAAAATTACTACGGCATTAGCATAGTGCCGTGAGAGTGATGTAGTA

例子4-2与例子4-1有许多相似之处，让我们来看看差异。首先，print语句部分：

print(DNA1, "\n")print(DNA2, "\n\n")

print(DNA1, DNA2, "\n", sep='')

如前所述，print语句包含储存DNA的变量，但现在它们也有逗号，然后是“\n”或“\n\n”，关键字参数“sep=''”。“\n”是换行符，告诉计算机继续下一行的开头进行后续打印。一个换行符“\n”，只是将你定位在下一行的开头，两个新行“\n\n”移动到下一行，然后在此之后将行放在行的开头，在它们之间留下一个空行。关键字参数“sep=''”告诉每个打印对象（DNA1、DNA2）之间使用''进行连接，默认是一个空格。print语句打印逗号分隔列表中的所有项目。

现在让我们看一下将DNA片段DNA1和DNA2连接到变量DNA3的语句。

DNA3 = "%s%s" % (DNA1, DNA2)

这是类似于例子4-1中的赋值语句。右侧的值是python字符串格式化方式，两个“%s”分别替换成DNA1、DNA2中储存的字符串，然后将这两个DNA片段连接赋值给变量DNA3。

将连接的DNA赋值给变量DNA后，然后与空白行一起打印出来。

print("%s\n\n" % DNA3)

程序的下一部分显示了使用“+”运算符连接两个字符串的另一种方法。

DNA3 = DNA1 + DNA2

最后，我们使用print语句完成相同的连接：

print(DNA1, DNA2, "\n", sep='')

这里的print语句有四个部分，用逗号分隔：两个变量中的两个DNA片段和一个换行符，关键字参数“sep=''”。

　　4.DNA转录到RNA

例子4-3是另一个操纵DNA的程序，它将DNA转录为RNA。在细胞中，DNA向RNA的转录是精细复杂和纠错机制共同运作的结果。本程序是一个简单地模拟，当DNA被转录为RNA时，所有的T都被改为U，这就是我们程序知道的所有内容。

例子4-3 DNA转录成RNA

#!/usr/bin/env python# Transcribing DNA into RNA# The DNADNA = 'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'# Print the DNA onto the screenprint("Here is the starting DNA:\n\n")print("%s\n\n" % DNA)# Transcribe the DNA to RNA by substituting all T's with U's.RNA = DNA.replace('T', 'U')# Print the RNA onto the screenprint("Here is the result of transcribing the DNA to RNA:\n\n")print("%s\n" % RNA)# Exit the program.exit()

如下是例子4-3的输出：

Here is the starting DNA:ACGGGAGGACGGGAAAATTACTACGGCATTAGCHere is the result of transcribing the DNA to RNA:ACGGGAGGACGGGAAAAUUACUACGGCAUUAGC

这个简短的程序介绍了Python的一个重要部分：能够轻松操作文本数据，如一串DNA。操作可以有许多不同的类型：翻译、反转、替换、删除、重新排序等。

首先，程序定义DNA变量，并进行赋值。然后，调用字符串对象内置方法replace进行T→U替换，得到新的字符串对象并赋值给变量RNA。

　　5.使用Python文档

Python程序员最重要的资源是Python文档，它应该安装在你的计算机上，也可以在Internet上的Python站点找到。查看他们提供的示例，了解语言功能的实际使用方式，这通常是寻找知识最快捷方式。

　　6. 在Python计算反向互补序列

从第一章中我们知道DNA聚合物由核苷酸组成，根据双螺旋结构中两条DNA链之间的密切关系，编写一个给定一条链，打印另一条链的程序是非常简单的。这种就算是许多生物信息学应用的重要部分，例如，当提交DNA序列搜素数据库时，通常会自动搜索反向互补序列，因为该序列可能是某个基因的反向互补链。

例子4-4，使用了Python的一些新功能。首先尝试了一个失败的方式，然后尝试了另一个成功的方法。

例子4-4 计算DNA链的反向互补链

#!/usr/bin/perl -w# Calculating the reverse complement of a strand of DNA# The DNADNA = 'ACGGGAGGACGGGAAAATTACTACGGCATTAGC'# Print the DNA onto the screenprint("Here is the starting DNA:\n\n")print("%s\n\n" % DNA)# Calculate the reverse complement# Warning: this attempt will fail!## First, copy the DNA into new variable revcom # (short for REVerse COMplement)# Notice that variable names can use lowercase letters like# "revcom" as well as uppercase like "DNA". In fact,# lowercase is more common.## It doesn't matter if we first reverse the string and then# do the complementation; or if we first do the complementation# and then reverse the string. Same result each time.# So when we make the copy we'll do the reverse in the same statement.#revcom = DNA[::-1]## Next substitute all bases by their complements,# A->T, T->A, G->C, C->G#revcom = revcom.replace('A', 'T')revcom = revcom.replace('T', 'A')revcom = revcom.replace('G', 'C')revcom = revcom.replace('C', 'G')# Print the reverse complement DNA onto the screenprint("Here is the reverse complement DNA:\n\n")print("%s\n" % revcom)## Oh-oh, that didn't work right!# Our reverse complement should have all the bases in it, since the# original DNA had all the bases--but ours only has A and G!## Do you see why?## The problem is that the first two substitute commands above change# all the A's to T's (so there are no A's) and then all the# T's to A's (so all the original A's and T's are all now A's).# Same thing happens to the G's and C's all turning into G's.#print("\nThat was a bad algorithm, and the reverse complement was wrong!\n")print("Try again ... \n\n")# Make a new copy of the DNA (see why we saved the original?)revcom = DNA[::-1]# See the text for a discussion of str.maketrans('ATCGatcg', 'TAGCtagc')revcom =revcom.translate(str.maketrans('ATCGatcg', 'TAGCtagc'))# Print the reverse complement DNA onto the screenprint("Here is the reverse complement DNA:\n\n")print("%s\n" % revcom)print("\nThis time it worked!\n\n")exit()

以下是示例4-4的输出：

Here is the starting DNA:ACGGGAGGACGGGAAAATTACTACGGCATTAGCHere is the reverse complement DNA:GGAAAAGGGGAAGAAAAAAAGGGGAGGAGGGGAThat was a bad algorithm, and the reverse complement was wrong!Try again ... Here is the reverse complement DNA:GCTAATGCCGTAGTAATTTTCCCGTCCTCCCGTThis time it worked!

你可以从左到右阅读第一条链，从右到左阅读第二条链来检查DNA是否彼此反向互补，及读取两条链时，每对碱基应该是GC或AT配对。在例子4-4中，计算反向互补链第一次尝试失败了，因为字符串中的每个碱基都作为整体翻译，使用全局方式替换了四次；在第五章中，另一种方式通过DNA从左到右遍历，一次查看一个碱基，然后替换，直到字符串末尾。然后只需反转字符串就完成了。

在例子4-4第二种方式中，使用字符串自带的maketrans和translate函数就可以完成翻译任务。

反向功能操作也比较简单，使用字符串切片方式，旨在颠倒元素的顺序，包括如例子4-4中所示的字符串。

　　7. 蛋白质、文件和数组

到目前为止，我们一直在用DNA序列数据编写程序。现在我们操作同样重要的蛋白质序列数据。以下是对各节中介绍的内容啊概述：

如何在Python程序中使用蛋白质序列数据

如何从文件中读取蛋白质序列数据

Python语言中的数组

本章的其余部分，蛋白质和DNA序列数据都会用到。

　　8. 读取文件中的蛋白质

程序与计算机磁盘上的文件进行交互，这些文件可以在硬盘、CD、软盘、Zip驱动器、磁带等上永久储存。

我们来看看如何从文件中读取蛋白质序列数据。首先，在你的计算机上创建一个文件（使用文本编辑器），并将一些蛋白质序列数据放入其中，命名为NM_021964fragment.pep。你将使用以下数据（人类锌指蛋白NM_021964的一部分）：

MNIDDKLEGLFLKCGGIDEMQSSRTMVVMGGVSGQSTVSGELQDSVLQDRSMPHQEILAADEVLQESEMRQQDMISHDELMVHEETVKNDEEQMETHERLPQGLQYALNVPISVKQEITFTDVSEQLMRDKKQIR

该文件你可以任意命名，但已在同一文件夹中使用的名称除外。

正如选择良好的变量名称对于理解程序至关重要一样，精心挑选的文件和文件夹名称也很重要。如果你有一个生成大量计算机文件的项目，则需要仔细考虑如何命名和组织文件和文件夹。

文件名NM_021964fragment.pep取自发现该蛋白质的记录的GenBank ID、数据的片段性质，并包含文件扩展名.pep，以提醒你该文件包含肽或蛋白质序列数据。当然，其他一些方案也许对你更好，关键是不用查看文件而了解文件内容。

现在你已经有了包含蛋白质序列数据的文件，让我们开发一个程序，从文件中读取蛋白质序列数据并将其储存到变量中。例子4-5显示了第一次尝试。

例子4-5 从文件中读取蛋白质序列数据

#!/usr/bin/env python# Reading protein sequence data from a file# The filename of the file containing the protein sequence dataproteinfilename = 'NM_021964fragment.pep'# First we have to "open" the file, and associate# a "filehandle" with it. We choose the filehandle# PROTEINFILE for readability.PROTEINFILE = open(proteinfilename)# Now we do the actual reading of the protein sequence data from the file,# by using the read function to get the input from the# filehandle. We store the data into our variable protein.protein = PROTEINFILE.readline();# Now that we've got our data, we can close the file.PROTEINFILE.close()# Print the protein onto the screenprint("Here is the protein:\n\n")print(protein)exit()

例子4-5输出结果：

Here is the protein:MNIDDKLEGLFLKCGGIDEMQSSRTMVVMGGVSGQSTVSGELQD

注意，该程序只打印出文件的第一行，我马上就会说名原因。

让我详细解析一下例子4-5，将文件名放入变量proteinfilename后，将使用以下语句打开该文件：

PROTEINFILE = open(proteinfilename)

打开文件后，你可以使用它执行各种操作，例如读取、写入、搜索、转到文件中的特定位置，删除文件中的所有内容等等。注意，程序假定变量proteinfilename中指定的文件存在且可以打开，如果文件不存在，你将收到一些错误消息，稍后你将看到如何检查。

如果你查看open函数的文档，你会看到很多选项。通常，它们使你能够准确指定文件打开后怎么操作。

我们来看看术语PROTEINFILE，它被称为文件句柄，理解它们的真实含义并不重要。它们只是你处理文件时使用的内容，在open函数赋值文件句柄之后，通过命名文件句柄完成与文件的所有交互。

实际上调用文件句柄的readline函数将数据读入程序：

protein = PROTEINFILE.readline()

但是如你所看到的那样，程序只打印此多行文件的第一行。为什么？因为还有一些关于阅读文件的东西需要学习。有几种方法可以读取整个文件。例子4-6显示了一种方法。

例子4-6 从文件中读取蛋白质序列数据 2

#!/usr/bin/envl python# Reading protein sequence data from a file, take 2# The filename of the file containing the protein sequence dataproteinfilename = 'NM_021964fragment.pep'# First we have to "open" the file, and associate# a "filehandle" with it. We choose the filehandle# PROTEINFILE for readability.PROTEINFILE = open(proteinfilename)# Now we do the actual reading of the protein sequence data from the file,# by using the function readline to get the input from the# filehandle. We store the data into our variable $protein.## Since the file has three lines, and since the read only is# returning one line, we'll read a line and print it, three times.# First lineprotein = PROTEINFILE.readline()# Print the protein onto the screenprint("\nHere is the first line of the protein file:\n\n")print($protein)# Second lineprotein = PROTEINFILE.readline()# Print the protein onto the screenprint("\nHere is the second line of the protein file:\n\n")print(protein)# Third lineprotein = PROTEINFILE.readline()# Print the protein onto the screenprint("\nHere is the third line of the protein file:\n\n")print(protein)# Now that we've got our data, we can close the file.PROTEINFILE.close()exit()

例子4-6输出如下：

Here is the first line of the protein file:MNIDDKLEGLFLKCGGIDEMQSSRTMVVMGGVSGQSTVSGELQDHere is the second line of the protein file:SVLQDRSMPHQEILAADEVLQESEMRQQDMISHDELMVHEETVKNDEEQMETHERLPQHere is the third line of the protein file:GLQYALNVPISVKQEITFTDVSEQLMRDKKQIR

这个程序的有趣之处在于它显示了如何从文件中读取数据。每次读入变量protein时，都会读取文件的下一行。另一方面，该程序的缺点是显而易见的，必须为输入文件的每一行写几行代码是不方便的。但是，利用Python的列表和循环（第五章中）可以很好处理这个问题。

例子4-7 从文件中读取蛋白质序列数据 3

#!/usr/bin/env python# Reading protein sequence data from a file, take 3# The filename of the file containing the protein sequence dataproteinfilename = 'NM_021964fragment.pep'# First we have to "open" the filePROTEINFILE = open(proteinfilename)# Read the protein sequence data from the file, and store it# into the array variable proteinsproteins = PROTEINFILE.readlines()# Print the protein onto the screenprint(*proteins, sep='')# Close the file.PROTEINFILE.close()exit()

例子4-7输出如下：

MNIDDKLEGLFLKCGGIDEMQSSRTMVVMGGVSGQSTVSGELQDSVLQDRSMPHQEILAADEVLQESEMRQQDMISHDELMVHEETVKNDEEQMETHERLPQGLQYALNVPISVKQEITFTDVSEQLMRDKKQIR

正如你所看到的，打印了文件中的所有数据，运行成功！

请注意，Python中的变量可以赋值为任何类型，另外，“*”将多个元素的列表解包为print函数的多个对象，然后print函数打印每个对象。

列表是一个可以包含许多标量的变量，每个项目或元素都是一个标量值，可以通过它在列表中的位置（下表或偏移量）来引用。来看一些列表的例子及常见的操作，我们将定义一个包含四个碱基A、C、G和T的数组bases，然后应用于一些最常见的数组运算符。

这是一段演示了如何初始化数组以及如何使用下标来访问数组的各个元素：

# Here's one way to declare an array, initialized with a list of four scalar values.bases = ['A', 'C', 'G', 'T']# Now we'll print each element of the arrayprint("Here are the array elements:")print("\nFirst element: ")print(bases[0])print("\nSecond element: ")print(bases[1])print("\nThird element: ")print(bases[2])print("\nFourth element: ")print(bases[3])

此段代码打印结果：

First element: ASecond element: CThird element: GFourth element: T

你可以像这样一个接一个地打印元素：

bases = ['A', 'C', 'G', 'T']print("\n\nHere are the array elements: ")print(*bases, sep='')

输出如下：

Here are the array elements: ACGT

你还可以打印空格分隔的元素：

bases = ['A', 'C', 'G', 'T']print("\n\nHere are the array elements: ")print(*bases)

输出如下：

Here are the array elements: A C G T

您可以使用pop函数从列表的末尾获取一个碱基：

bases = ['A', 'C', 'G', 'T']base1 = bases.pop()print("Here's the element removed from the end: ")print(base1, "\n\n")print("Here's the remaining array of bases: ")print(*bases)

输出如下：

Here's the element removed from the end: THere's the remaining array of bases: A C G

你可以使用pop函数从列表的开头取一个碱基：

bases = ['A', 'C', 'G', 'T']base2 = bases.pop(0)print("Here's an element removed from the beginning: ")print(base2, "\n\n")print("Here's the remaining array of bases: ")print(*bases)

输出如下：

Here's an element removed from the beginning: AHere's the remaining array of bases: C G T

你可以使用insert函数将元素放在列表的开头：

bases = ['A', 'C', 'G', 'T']base1 = bases.pop()bases.insert(0, base1)print("Here's the element from the end put on the beginning: ")print(*bases, "\n\n")

输出结果：

Here's the element from the end put on the beginning: T A C G

你可以使用append函数将元素放在列表的末尾：

bases = ['A', 'C', 'G', 'T']base2 = bases.pop(0)bases.append(base2)print("Here's the element from the beginning put on the end: ")print(*bases, "\n\n")

输出结果：

Here's the element from the beginning put on the end: C G T A

你可以使用reverse函数反转列表：

bases = ['A', 'C', 'G', 'T']reverse = bases.reverse()print("Here's the array in reverse: ")print(reverse, "\n\n")

输出结果：

Here's the array in reverse: T G C A

你可以使用len函数计算列表长度：

bases = ['A', 'C', 'G', 'T']print("Here's the length of the array: "， len(bases))

输出结果：

Here's the length of the array: 4

以下是使用insert函数在列表中的任意位置插入元素的方法：

bases = ['A', 'C', 'G', 'T']bases.insert(2, 'X')print("Here's the array with an element inserted after the 2nd element: ", *bases)

输出结果：

Here's the array with an element inserted after the 2nd element: A C X G T10. 练习

习题1 探索编程语言对语法错误的敏感性。尝试print函数拼写错误、更改语法项等，注意一个错误导致多行错误报告，查看Python是否准确报告错误所在行。

习题2 编写一个程序，在变量中储存一个整数，然后将其打印出来。

习题3编写一个程序，以小写字母（acgt）打印DNA（最初可能是大写或小写）; 写另一个用大写字母打印DNA（ACGT）。使用函数maketrans和translate。

习题4有时信息从RNA流向DNA，编写程序将RNA反转录为DNA。

习题5 读取两个数据文件，打印第一个内容，然后打印第二个内容。

习题6 编写程序读取文件，然后倒着打印内容。