计算机的概念：计算机是 根据指令操作数据的设备 。

计算机具有 功能性 和 可编程性。

功能性，指对数据的操作，表现为数据计算、输入输出处理和结果存储等。

可编程性，指根据一系列指令自动地、可预测地、准确地完成操作者的意图。

计算机的发展参照 摩尔定律 ，表现为指数方式。

计算机硬件所依赖的集成电路规模参照摩尔定律发展，计算机运行速度因此也接近几何级数快速增长，计算机高效支撑的各类运算功能不断丰富发展。

摩尔定律 Moore’s Law——计算机发展 历史 上最重要的预测法则

Intel公司创始人之一戈登·摩尔在1965年提出单位面积集成电路上可容纳晶体管的数量约每两年翻一番，CPU/GPU、内存、硬盘、电子产品价格等都遵循摩尔定律。计算机是当今世界，唯一长达50年有效且按照指数发展的技术领域，计算机深刻改变人类 社会 ，甚至可能改变人类本身，可预见的未来30年，摩尔定律还将持续有效。

程序设计

程序设计是计算机可编程性的体现。

程序设计，亦称编程，是深度应用计算机的主要手段，程序设计已经成为当今 社会 需求量最大的职业技能之一，很多岗位都将被计算机程序接管，程序设计将是生存技能。

程序设计语言

程序设计语言是一种用于交互(交流)的人造语言。

程序设计语言，亦称编程语言，是程序设计的具体实现方式，编程语言相比自然语言更简单、更严谨、更精确，编程语言相比自然语言更简单、更严谨、更精确。

编程语言种类很多，但生命力强劲的却不多。编程语言有超过600种，绝大部分都不再被使用。C语言诞生于1972年，它是第一个被广泛使用的编程语言，Python语言诞生于1990年，它是最流行最好用的编程语言。

编程语言的执行方式

计算机执行源程序的两种方式：编译和解释。

源代码：采用某种编程语言编写的计算机程序，人类可读。

例如：result = 2 + 3

目标代码：计算机可直接执行，人类不可读 (专家除外)。

例如：11010010 00111011

编译

将源代码一次性转换成目标代码的过程。

执行编译过程的程序叫作编译器（compiler）。

解释

将源代码逐条转换成目标代码同时逐条运行的过程

执行解释过程的程序叫做解释器（interpreter）。

编译和解释

编译：一次性翻译，之后不再需要源代码（类似英文翻译）。

解释：每次程序运行时随翻译随执行（类似实时的同声传译）。

静态语言和脚本语言

根据执行方式不同，编程语言分为两类。

静态语言：使用编译执行的编程语言，如C/C++语言、Java语言。

脚本语言：使用解释执行的编程语言，如Python语言、JavaScript语言、PHP语言。

执行方式不同，优势也各有不同。

静态语言：编译器一次性生成目标代码，优化更充分，程序运行速度更快。

脚本语言：执行程序时需要源代码，维护更灵活，源代码在维护灵活、跨多个操作系统平台。

IPO

程序的基本编写方法。

I：Input 输入，程序的输入。

P：Process 处理，是程序的主要逻辑。

O：Output 输出，程序的输出。

理解IPO

输入 ，程序的输入 文件输入、网络输入、控制台输入、交互界面输入、内部参数输入等，输入是一个程序的开始。

输出 ，程序的输出，控制台输出、图形输出、文件输出、网络输出、操作系统内部变量输出等，输出是程序展示运算结果的方式。

处理 ，处理是程序对输入数据进行计算产生输出结果的过程，处理方法统称为 算法 ，它是程序最重要的部分，算法是一个程序的灵魂。

问题的计算部分

一个待解决的问题中，可以用程序辅助完成的部分。

计算机只能解决计算问题，即问题的计算部分，一个问题可能有多种角度理解，产生不同的计算部分，问题的计算部分一般都有输入、处理和输出过程。

编程解决问题的步骤

6个步骤 (1-6)

分析问题 ：分析问题的计算部分，想清楚。

划分边界 ：划分问题的功能边界，规划IPO。

编写程序 ：编写问题的计算机程序，编程序。

调试测试 ：调试程序是正确运行的，运行调试。

升级维护 ：适应问题的升级维护，更新完善。

求解计算问题的精简步骤

3个精简步骤

确定IPO ：明确计算部分及功能边界。

编写程序 ：将计算求解的设计变成现实。

调试程序 ：确保程序按照正确逻辑能够正确运行。

编程能够训练思维

编程体现了一种抽象交互关系、自动化执行的思维模式。计算思维：区别逻辑思维和实证思维的第三种思维模式。能够促进人类思考，增进观察力和深化对交互关系的理解。

编程能够增进认识

编程不单纯是求解计算问题。不仅要思考解决方法，还要思考用户体验、执行效率等方面。能够帮助程序员加深对用户行为以及 社会 和文化的认识。

编程能够带来乐趣

编程能够提供展示自身思想和能力的舞台。让世界增加新的颜色、让自己变得更酷、提升心理满足感。在信息空间里思考创新、将创新变为现实。

编程能够提高效率

能够更好地利用计算机解决问题。显著提高工作、生活和学习效率。为个人理想实现提供一种借助计算机的高效手段。

编程带来就业机会

程序员是信息时代最重要的工作岗位之一。国内外对程序员岗位的缺口都在百万以上规模。计算机已经渗透于各个行业， 就业前景非常广阔。

学习编程的误区

Q：编程很难学吗？ A：掌握方法就很容易！

首先，掌握编程语言的语法，熟悉基本概念和逻辑。其次，结合计算问题思考程序结构，会使用编程套路。最后，参照案例多练习多实践，学会举一反三次。

GIL 与 Python 线程的纠葛

GIL 是什么东西？它对我们的 python 程序会产生什么样的影响？我们先来看一个问题。运行下面这段 python 程序，CPU 占用率是多少？

# 请勿在工作中模仿，危险:)

def dead_loop():

while True:

pass

dead_loop()

答案是什么呢，占用 100％ CPU？那是单核！还得是没有超线程的古董 CPU。在我的双核 CPU 上，这个死循环只会吃掉我一个核的工作负荷，也就是只占用 50％ CPU。那如何能让它在双核机器上占用 100％ 的 CPU 呢？答案很容易想到，用两个线程就行了，线程不正是并发分享 CPU 运算资源的吗。可惜答案虽然对了，但做起来可没那么简单。下面的程序在主线程之外又起了一个死循环的线程

import threading

def dead_loop():

while True:

pass

# 新起一个死循环线程

t = threading.Thread(target=dead_loop)

t.start()

# 主线程也进入死循环

dead_loop()

t.join()

按道理它应该能做到占用两个核的 CPU 资源，可是实际运行情况却是没有什么改变，还是只占了 50％ CPU 不到。这又是为什么呢？难道 python 线程不是操作系统的原生线程？打开 system monitor 一探究竟，这个占了 50% 的 python 进程确实是有两个线程在跑。那这两个死循环的线程为何不能占满双核 CPU 资源呢？其实幕后的黑手就是 GIL。

GIL 的迷思：痛并快乐着

GIL 的全称为 Global Interpreter Lock ，意即全局解释器锁。在 Python 语言的主流实现 CPython 中，GIL 是一个货真价实的全局线程锁，在解释器解释执行任何 Python 代码时，都需要先获得这把锁才行，在遇到 I/O 操作时会释放这把锁。如果是纯计算的程序，没有 I/O 操作，解释器会每隔 100 次操作就释放这把锁，让别的线程有机会执行（这个次数可以通过sys.setcheckinterval 来调整）。所以虽然 CPython 的线程库直接封装操作系统的原生线程，但 CPython 进程做为一个整体，同一时间只会有一个获得了 GIL 的线程在跑，其它的线程都处于等待状态等着 GIL 的释放。这也就解释了我们上面的实验结果：虽然有两个死循环的线程，而且有两个物理 CPU 内核，但因为 GIL 的限制，两个线程只是做着分时切换，总的 CPU 占用率还略低于 50％。

看起来 python 很不给力啊。GIL 直接导致 CPython 不能利用物理多核的性能加速运算。那为什么会有这样的设计呢？我猜想应该还是历史遗留问题。多核 CPU 在 1990 年代还属于类科幻，Guido van Rossum 在创造 python 的时候，也想不到他的语言有一天会被用到很可能 1000＋ 个核的 CPU 上面，一个全局锁搞定多线程安全在那个时代应该是最简单经济的设计了。简单而又能满足需求，那就是合适的设计（对设计来说，应该只有合适与否，而没有好与不好）。怪只怪硬件的发展实在太快了，摩尔定律给软件业的红利这么快就要到头了。短短 20 年不到，代码工人就不能指望仅仅靠升级 CPU 就能让老软件跑的更快了。在多核时代，编程的免费午餐没有了。如果程序不能用并发挤干每个核的运算性能，那就意谓着会被淘汰。对软件如此，对语言也是一样。那 Python 的对策呢？

Python 的应对很简单，以不变应万变。在最新的 python 3 中依然有 GIL。之所以不去掉，原因嘛，不外以下几点：

欲练神功，挥刀自宫：

CPython 的 GIL 本意是用来保护所有全局的解释器和环境状态变量的。如果去掉 GIL，就需要多个更细粒度的锁对解释器的众多全局状态进行保护。或者采用 Lock-Free 算法。无论哪一种，要做到多线程安全都会比单使用 GIL 一个锁要难的多。而且改动的对象还是有 20 年历史的 CPython 代码树，更不论有这么多第三方的扩展也在依赖 GIL。对 Python 社区来说，这不异于挥刀自宫，重新来过。

就算自宫，也未必成功：

有位牛人曾经做了一个验证用的 CPython，将 GIL 去掉，加入了更多的细粒度锁。但是经过实际的测试，对单线程程序来说，这个版本有很大的性能下降，只有在利用的物理 CPU 超过一定数目后，才会比 GIL 版本的性能好。这也难怪。单线程本来就不需要什么锁。单就锁管理本身来说，锁 GIL 这个粗粒度的锁肯定比管理众多细粒度的锁要快的多。而现在绝大部分的 python 程序都是单线程的。再者，从需求来说，使用 python 绝不是因为看中它的运算性能。就算能利用多核，它的性能也不可能和 C/C++ 比肩。费了大力气把 GIL 拿掉，反而让大部分的程序都变慢了，这不是南辕北辙吗。

难道 Python 这么优秀的语言真的仅仅因为改动困难和意义不大就放弃多核时代了吗？其实，不做改动最最重要的原因还在于：不用自宫，也一样能成功！

其它神功

那除了切掉 GIL 外，果然还有方法让 Python 在多核时代活的滋润？让我们回到本文最初的那个问题：如何能让这个死循环的 Python 脚本在双核机器上占用 100％ 的 CPU？其实最简单的答案应该是：运行两个 python 死循环的程序！也就是说，用两个分别占满一个 CPU 内核的 python 进程来做到。确实，多进程也是利用多个 CPU 的好方法。只是进程间内存地址空间独立，互相协同通信要比多线程麻烦很多。有感于此，Python 在 2.6 里新引入了 multiprocessing这个多进程标准库，让多进程的 python 程序编写简化到类似多线程的程度，大大减轻了 GIL 带来的不能利用多核的尴尬。

这还只是一个方法，如果不想用多进程这样重量级的解决方案，还有个更彻底的方案，放弃 Python，改用 C/C++。当然，你也不用做的这么绝，只需要把关键部分用 C/C++ 写成 Python 扩展，其它部分还是用 Python 来写，让 Python 的归 Python，C 的归 C。一般计算密集性的程序都会用 C 代码编写并通过扩展的方式集成到 Python 脚本里（如 NumPy 模块）。在扩展里就完全可以用 C 创建原生线程，而且不用锁 GIL，充分利用 CPU 的计算资源了。不过，写 Python 扩展总是让人觉得很复杂。好在 Python 还有另一种与 C 模块进行互通的机制 : ctypes

利用 ctypes 绕过 GIL

ctypes 与 Python 扩展不同，它可以让 Python 直接调用任意的 C 动态库的导出函数。你所要做的只是用 ctypes 写些 python 代码即可。最酷的是，ctypes 会在调用 C 函数前释放 GIL。所以，我们可以通过 ctypes 和 C 动态库来让 python 充分利用物理内核的计算能力。让我们来实际验证一下，这次我们用 C 写一个死循环函数

extern"C"

{

void DeadLoop()

{

while (true)

}

}

用上面的 C 代码编译生成动态库 libdead_loop.so （Windows 上是 dead_loop.dll）

，接着就要利用 ctypes 来在 python 里 load 这个动态库，分别在主线程和新建线程里调用其中的 DeadLoop

from ctypes import *

from threading import Thread

lib = cdll.LoadLibrary("libdead_loop.so")

t = Thread(target=lib.DeadLoop)

t.start()

lib.DeadLoop()

这回再看看 system monitor，Python 解释器进程有两个线程在跑，而且双核 CPU 全被占满了，ctypes 确实很给力！需要提醒的是，GIL 是被 ctypes 在调用 C 函数前释放的。但是 Python 解释器还是会在执行任意一段 Python 代码时锁 GIL 的。如果你使用 Python 的代码做为 C 函数的 callback，那么只要 Python 的 callback 方法被执行时，GIL 还是会跳出来的。比如下面的例子：

extern"C"

{

typedef void Callback()

void Call(Callback* callback)

{

callback()

}

}

from ctypes import *

from threading import Thread

def dead_loop():

while True:

pass

lib = cdll.LoadLibrary("libcall.so")

Callback = CFUNCTYPE(None)

callback = Callback(dead_loop)

t = Thread(target=lib.Call, args=(callback,))

t.start()

lib.Call(callback)

注意这里与上个例子的不同之处，这次的死循环是发生在 Python 代码里 (DeadLoop 函数) 而 C 代码只是负责去调用这个 callback 而已。运行这个例子，你会发现 CPU 占用率还是只有 50％ 不到。GIL 又起作用了。

其实，从上面的例子，我们还能看出 ctypes 的一个应用，那就是用 Python 写自动化测试用例，通过 ctypes 直接调用 C 模块的接口来对这个模块进行黑盒测试，哪怕是有关该模块 C 接口的多线程安全方面的测试，ctypes 也一样能做到。

结语

虽然 CPython 的线程库封装了操作系统的原生线程，但却因为 GIL 的存在导致多线程不能利用多个 CPU 内核的计算能力。好在现在 Python 有了易经筋（multiprocessing）, 吸星大法（C 语言扩展机制）和独孤九剑（ctypes），足以应付多核时代的挑战，GIL 切还是不切已经不重要了，不是吗。

Pymol 是一个结构显示和分析程序.

它是用python编写的所以叫pymol，相应的还有Jmol 等。

Pymol 的好处是做出来的图很炫。很多牛人用它做图发文章，蛋白质结构预测里面现在最牛的Baker，他们2005年Science的文章中那些漂亮的图可都是Pymol做出来的。

再者Pymol是开源的（1.0之前的版本现在还是开源的，1.0版以后可以申请教师用的免费版,现在版本是1.0），Python也是开源的。以后大家可以对Pymol进行扩展，打造自己的三维结构显示软件。

Pymol可以精确定量你的操作，并放在一个文件中(或者是记录这时的状态）。

下次你用Pymol再打开这个文件时，你做的图就会重新出现，你所做的一切都保留下来了，不用重新在做一遍。 不会出现这次做出的图比上次少转了3-5度这样的事。Pymol还可以对pdb文件进行编辑，修改，它选择原子、分子、残基等也非常方便！ 还有很多好处比如从虚拟氨基酸突变，到ray方法产生真正的三维立体阴影图。

---