Python编程解密生物信息学

5星 · 超过95%的资源需积分: 13 61 浏览量更新于2024-07-19 收藏 3.16MB PDF 举报

"Bioinformatics Programming using python" 《Bioinformatics Programming Using Python》是一本专门针对生物信息学编程的指南，通过丰富的实例和练习帮助简化使用Python进行生物信息学编程的过程。这本书适合两类读者：一是希望学习基础脚本或进行各种计算任务的生物学家，二是想要涉足生物信息学编程的程序员。无论你是计算机科学、生物学还是其他生命科学领域的本科生，或是进修专业硕士课程的研究生，这本书都能提供详尽的指导。书中涵盖了Python在生物信息学中的应用，包括但不限于序列比对、基因组分析、蛋白质结构预测等核心概念。作者Mitchell L. Model深入浅出地讲解了如何利用Python解决生物信息学中的实际问题，不仅教授编程技能，还强调了解决生物学问题的策略和方法。书中的每个章节都可能包含实际的代码示例，让读者能够动手实践，从而加深理解。此外，本书还适合用作自学资料或大学课程的配套教材。它提供了充足的细节，使得无论是初学者还是有经验的程序员，都能从中获益。在线版本（如Safari Books Online）也方便读者随时随地查阅和学习。编辑方面，由Mike Loukides负责，Sarah Schneider担任生产编辑，Rachel Head进行校对，Sada Preisch负责校阅，Lucie Haskins编索引，封面设计由Karen Montgomery完成，内页设计由David Futato设计，插图由Robert Romano绘制。《Bioinformatics Programming Using Python》是学习生物信息学编程的宝贵资源，它将Python的强大功能与生物信息学的复杂需求相结合，帮助读者掌握这个交叉学科的关键技能。无论你是生物学家还是程序员，都能在这本书中找到提升自己技能的方法，从而更好地应对生命科学领域的挑战。

Some things that will appear strange to anyone with significant programming experi-

ence are in reality true to a pure “Pythonic” approach. It is delightful to have the

opportunity to write in this vocabulary without the need to accommodate more tradi-

tional terminology.

The most significant example of this is that the word “variable” is never used in the

context of assignment statements or function calls. Python does not assign values to

variables in the way that traditional “values in a box” languages do. Instead, like some

of the languages that influenced its design, what Python does is assign names to values.

The assignment statement should be read from left to right as assigning a name to an

existing value. This is a very real distinction that goes beyond the ways languages such

as Java and C++ refer to objects through pointer-valued variables.

Another aspect of the book’s heavily Pythonic approach is its routine use of compre-

hensions. Approached by someone familiar with other languages, these can appear

quite mysterious. For someone learning Python as a first language, though, they can

be more natural and easier to use than the corresponding combinations of assignments,

tests, and loops or iterations.

Python

This section introduces the Python language and gives instructions for installing and

running Python on your machine.

Some Context

There are many kinds of programming languages, with different purposes, styles, in-

tended uses, etc. Professional programmers often spend large portions of their careers

working with a single language, or perhaps a few similar ones. As a result, they are often

unaware of the many ways and levels at which programming languages can differ. For

educational and professional development purposes, it can be extremely valuable for

programmers to encounter languages that are fundamentally different from the ones

with which they are familiar.

The effects of such an encounter are similar to learning a foreign human language from

a different culture or language family. Learning Portuguese when you know Spanish is

not much of a mental stretch. Learning Russian when you are a native English speaker

is. Similarly, learning Java is quite easy for experienced C++ programmers, but learning

Lisp, Smalltalk, ML, or Perl would be a completely different experience.

Broadly speaking, programming languages embody combinations of four paradigms.

Some were designed with the intention of staying within the bounds of just one, or

perhaps two. Others mix multiple paradigms, although in these cases one is usually

dominant. The paradigms are:

Preface | xv

Procedural

This is the traditional kind of programming language in which computation is

described as a series of steps to be executed by the computer, along with a few

mechanisms for branching, repetition, and subroutine calling. It dates back to the

earliest days of computing and is still a core aspect of most modern languages,

including those designed for other paradigms.

Declarative

Declarative programming is based on statements of facts and logical deduction

systems that derive further facts from those. The primary embodiment of the logic

programming paradigm is Prolog, a language used fairly widely in Artificial Intel-

ligence (AI) research and applications starting in the 1980s. As a purely logic-based

language, Prolog expresses computation as a series of predicate calculus assertions,

in effect creating a puzzle for the system to solve.

Functional

In a purely functional language, all computation is expressed as function calls. In

a truly pure language there aren’t even any variable assignments, just function

parameters. Lisp was the earliest functional programming language, dating back

to 1958. Its name is an acronym for “LISt Processing language,” a reference to the

kind of data structure on which it is based.

Lisp became the dominant language of AI in the 1960s and still plays a major role

in AI research and applications. The language has evolved substantially from its

early beginnings and spawned many implementations and dialects, although most

of these disappeared as hardware platforms and operating systems became more

standardized in the 1980s.

A huge standardization effort combining ideas from several major dialects and a

great many extensions, including a complete object-oriented (see below) compo-

nent, was undertaken in the late 1980s. This effort resulted in the now-dominant

CommonLisp.

Two important dialects with long histories and extensive current

use are Scheme and Emacs Lisp, the scripting language for the Emacs editor. Other

functional programming languages in current use are ML and Haskell.

Object-oriented

Object-oriented programming was invented in the late 1960s, developed in the

research community in the 1970s, and incorporated into languages that spread

widely into both academic and commercial environments in the 1980s (primarily

Smalltalk, Objective-C, and C++). In the 1990s this paradigm became a key part

of modern software development approaches. Smalltalk and Lisp continued to be

used, C++ became dominant, and Java was introduced. Mac OS X, though built

on a Unix-like kernel, uses Objective-C for upper layers of the system, especially

the user interface, as do applications built for Mac OS X. JavaScript, used primarily

to program web browser actions, is another object-oriented language. Once a

* See http://www.lispworks.com/documentation/HyperSpec/Body/01_ab.htm.

xvi | Preface

radical innovation, object-oriented programming is today very much a mainstream

paradigm.

Another dimension that distinguishes programming languages is their primary inten-

ded use. There have been languages focused on string matching, languages designed

for embedded devices, languages meant to be easy to learn, languages built for efficient

execution, languages designed for portability, languages that could be used interac-

tively, languages based largely on list data structures, and many other kinds.

Language designers, whether consciously or not, make choices in these and other

dimensions. Subsequent evolutions of their languages are subject to market forces,

intellectual trends, hardware developments, and so on. These influences may help a

language mature and reach a wider audience. They may also steer the language in

directions somewhat different from those originally intended.

The Python Language

Simply put, Python is a beautiful language. It is effective for everything from teaching

new programmers to advanced computer science study, from simple scripts to sophis-

ticated advanced applications. It has always had some purchase in bioinformatics, and

in recent years its popularity has been increasing rapidly. One goal of this book is to

help significantly expand Python’s use for bioinformatics programming.

Python features a syntax in which the ends of statements are marked only by the end

of a line, and statements that form part of a compound statement are indented relative

to the lines of code that introduce them. The semicolons or keywords that end state-

ments and the braces that group statements in other languages are entirely absent.

Programmers familiar with “standard syntax” languages often find Python’s unclut-

tered syntax deeply disconcerting. New programmers have no such problem, and for

them, this simple and readable syntax is far easier to deal with than the visually arcane

constructions using punctuation (with the attendant compilation errors that must be

confronted). Traditional programmers should reconsider Python’s syntax after per-

forming this experiment:

1. Open a file containing some well-formatted code.

2. Delete all semicolons, braces, and terminal keywords such as end, endif, etc.

3. Look at the result.

To the human eye, the simplified code is easier to read—and it looks an awful lot like

Python. It turns out that the semicolons, terminal keywords, and braces are primarily

for the benefit of the compiler. They are not really necessary for human writers and

readers of program code. Python frees the programmer from the drudgery of serving

as a compiler assistant.

Python is an interesting and powerful language with respect to computing paradigms.

Its skeleton is procedural, and it has been significantly influenced by functional

Preface | xvii

programming, but it has evolved into a fundamentally object-oriented language. (There

is no declarative programming component—of the four paradigms, declarative pro-

gramming is the one least amenable to fitting together with another.) Few, if any, other

languages provide a blend like this as seamlessly and elegantly as does Python.

Installing Python

This book uses Python 3, the language’s first non-backward-compatible release. With

a few minor changes, noted where applicable, Python 2.x will work for most of the

book’s examples. There are a few notes about Python 2 in Chapters 1, 3, and 5; they

are there not just to help you if you find yourself using Python 2 for some work, but

also for when you read Python 2 code. The major exception is that print was a statement

in Python 2 but is now a function, allowing for more flexibility. Also, Python 3 reor-

ganized and renamed some of its library modules and their contents, so using Python

2.x with examples that demonstrate the use of certain modules would involve more

than a few minor changes.

Determing Which Version of Python Is Installed

Some

version of Python 2 is probably installed on your computer, unless you are using

Windows. Typing the following into a command-line window (using % as an example

of a command-line prompt) will tell you which version of Python is installed as the

program called python:

% python -V

The name of the executable for Python 3 may be python3 instead of just python. You

can type this:

% python3 -V

to see if that is the case.

If you are running Python in an integrated development environment—in particular

IDLE, which is part of the Python installation—type the following at the prompt

(>>>) of its interactive shell window to get information about its version:

>>> from sys import version

>>> version

If this shows a version earlier than 3, look for another version of the IDE on your

computer, or install one that uses Python 3. (The Python installation process installs

the GUI-based IDLE for whatever version of Python is being installed.)

The current release of Python can be downloaded from http://python.org/download/.

Installers are available for OS X and Windows. With most distributions of Linux, you

should be able to install Python through the usual package mechanisms. (Get help from

someone who knows how to do that if you don’t.) You can also download the source,

xviii | Preface

unpack the archive, and, following the steps in the “Build Instructions” section of the

README file it contains, configure, “make,” and install the software.

If you are installing Python from its source code, you may need to

download, configure, make, and install several libraries that Python uses

if available. At the end of the “make” process, a list of missing optional

libraries is printed. It is not necessary to obtain all the libraries. The ones

you’ll want to have are:

• curses

• gdbm

• sqlite3

†

• Tcl/Tk

‡

• readline

All of these should be available through standard package installers.

Running Python

You can start Python in one of two ways:

1. Type python3 on the command line.

2. Run an IDE. Python comes with one called IDLE, which is sufficient for the work

you’ll do in this book and is a good place to start even if you eventually decide to

move on to a more sophisticated IDE.

The term Unix in this book refers to all flavors thereof, including Linux and Mac

OS X. The term command line refers to where you type commands to a “shell”—in

particular, a Unix shell such as tcsh or bash or a Windows command window—as

opposed to typing to the Python interpreter. The term interpreter may refer to either

the interpreter running in a shell, the “Python Shell” window in IDLE, or the corre-

sponding window in whatever other development environment you might be using.

† You can find precompiled binaries for most platforms at http://sqlite.org/download.html.

‡ See http://www.activestate.com/activetcl.

§ On OS X, a command-line shell is obtained by running the Terminal application, found in the Utilities folder

in the Applications folder. On most versions of Windows, a “Command Prompt” window can be opened

either by selecting Run from the Start menu and typing cmd or by selecting Accessories from the Start menu,

then the Command Prompt entry of that menu. You may also find an Open Command Line Here entry when

you right-click on a folder in a Windows Explorer window; this is perhaps the best way to start a command-

line Python interpreter in Windows because it starts Python with the selected folder as the current directory.

You may have to change your path settings to include the directory that contains the Python executable file.

On a Unix-based system, you do that in the “rc” file of the shell you are using (e.g., ~/.bashrc). On Windows,

you need to set the path as an environment variable, a rather arcane procedure that differs among different

versions of Windows. You can also type the full path to the Python executable; on Windows, for example,

that would probably be C:\\python3.1\\python.exe.

Preface | xix

剩余523页未读，继续阅读

qq_41589491

粉丝: 0
资源: 1

Python编程解密生物信息学

Python.Programming.for.Biology.Bioinformatics.and.Beyond.2015.pdf

生物信息经典教材第二版-Python for Bioinformatics-Chapman and Hall _ CRC (2017)

Bioinformatics Programming Using Python 无水印pdf

Bioinformatics Programming Using Python

Bioinformatics Programming Using Python.pdf.pdf

Model -- Bioinformatics Programming Using Python -- 2009.pdf

Bioinformatics with Python Cookbook(PACKT,2015)

Python for Bioinformatics 第二版，最新版

python.pdf

Advanced Python for Biologists

最新资源