话说，这道题，十几年前，玩论坛的时代，就出现在网上了：

三道门，一道门后面有车，另外两道门，后面都是羊。
有个节目主持人，他知道车在那道门后。
他请你选一道门，但不立即打开。
他在剩下的两道门里，打开一道，放出一只羊给你看。
现在台上还剩两道门关着，一道是你选的，一道是谁也没碰过的。
主持人说：现在你有个机会，可以改变主意，挑另一道门。
不管你换还是不换，你最终选中的那道门，后头的东西都归你。
你换不换？——假设价值观是车比羊好。

当时，论坛上吵成一片，有说该换的，有说不该换的。对于不换而中奖的概率，大家比较一致：1/3。而对于换而中奖的概率，基本上有三个说法：1/3、1/2、2/3。

论坛上贴题的那人说：“正确答案是应该换，中奖概率会从1/3提升到2/3。并且，此答案经过了智商排名极靠前的一位人士的认可。不过，还是有许多不愿盲信权威的年轻人，自己动手，用各种办法做实验，有大活人亲自做的，有用计算机模拟的，而结果一致确认：该换，中奖概率确实提升到了2/3。另外，虽然实验结果如此，有相当多的亲手做实验的人依然坚持（理论上）不该换。”

时至今日，这道题提到人口稠密的社交媒体上来，依然能够引起争论。

为了让读者老爷们怀着轻松的心情观看余下的内容，我提前把答案确认一下：

应该换。
我不是从一道门换到另一道门，
而是从一道门换到另外两道门。
“换并且选到车”的概率 = “第一次没选到车”的概率

三道门的迷惑性较大，读者可以极端化一下：如果是一亿道门，你挑一扇（选中车的概率很悲观），然后主持人把许许多多门打开，放出来满坑满谷的羊，最后只留下一道门，你换不换？

或者再换一个思路：主持人挑你和另外一个现场观众上来，让你选一道门，让那位观众选两道门，然后问你，愿不愿意拿你的一道门换那位观众的两道门？

“开门放羊”只是个迷惑动作，当门的总数大于2时，挑剩下的门里，一定能放出至少一只羊。所以它没有增加任何信息，也没有改变概率分布，这一步骤和事后开奖并无不同。

用概率论的运算过程则是：

• 换而中车的概率 =
          首次选羊的概率 × 拿羊换到车的概率 +
          首次选车的概率 × 拿车换到车的概率
• 首次选羊的概率 = 2/3
• 首次选车的概率 = 1/3
• 拿羊换到车的概率 = 100%
• 拿车换到车的概率 = 0%
• 因此，换而中车的概率 = 2/3

如果你看到这里还是觉得数学上不该换，那就可以关掉页面了。接下来并没有理论上的新内容，而且因为要用程序表达，技术上会比较烧脑。我不想让你同时背两个包袱走路，会芯片过热的。

 
虽然这道题没有数学理论难度，我还是想拿它做个编程的例子。原因是，我发现用计算机的思维，可以洞穿这道题的本质。做完实验依然坚持不该换的人里面，一定没有用计算机模拟的。

我的第一版程序很简单（手机读者可用手指左右拖动代码区）：

import random

def lottery(n, change):  # n是门的个数，change设置“换还是不换”
    car = random.randint(0, n - 1)   # 为车生成一个随机的门号
    pick = random.randint(0, n - 1)  # 我选择一个随机的门号
    # 如果我未选中车但愿意换，或者我选中了车并且不换
    if (pick != car and change) or (pick == car and not change):
        return True      # 我都会中奖
    else:                # 否则
        return False     # 就不会

repeat = 100      # 重复做此实验100次
win = 0           # “中奖”计数器置零
for i in range(repeat):
    if lottery(3, True):  # 每次都选择“换”
        win += 1          # 如果中奖，计数器加一
# 打印中奖百分比
print("%.2f%%" % (win / repeat * 100))

结果如何呢？运行三遍：

=============== RESTART: cargoat.py ===============
68.00%
>>> 
=============== RESTART: cargoat.py ===============
71.00%
>>> 
=============== RESTART: cargoat.py ===============
68.00%
>>> 

100次实验，如果选择“换”，中奖次数确实在2/3左右。当然我们也得反过来做一下，把lottery函数的第二个参数设为False：

repeat = 100      # 重复做此实验100次
win = 0           # “中奖”计数器置零
for i in range(repeat):
    if lottery(3, False):  # 每次都选择“不换”
        win += 1           # 如果中奖，计数器加一
# 打印中奖百分比
print("%.2f%%" % (win / repeat * 100))

运行三遍，选择“不换”的中奖概率确实较低：

=============== RESTART: cargoat.py ===============
34.00%
>>> 
=============== RESTART: cargoat.py ===============
34.00%
>>> 
=============== RESTART: cargoat.py ===============
27.00%
>>> 

还可以发现，实验的重复次数（repeat的值）越高，中奖概率越是稳定在2/3上，下面是repeat = 100000的三遍运行结果：

=============== RESTART: cargoat.py ===============
66.55%
>>> 
=============== RESTART: cargoat.py ===============
66.81%
>>> 
=============== RESTART: cargoat.py ===============
66.70%
>>> 

在这个程序里，原本热热闹闹的挑门、开门放羊、问你换不换的那些动作，一下子被简化成了“你第一次猜中的概率有多大”的问题。我刚才说：“做完实验依然坚持不该换的人里面，一定没有用计算机模拟的。”是因为写程序前，我先假装认为不该换，而写下lottery函数的前两行时，就找到了事情本质的描述方式（上面的粗大字体）。

 
然而，读者可能认为，我并没有精确地按照剧本来写，所以运算结果不可信。为此，我必须按照剧本写一遍程序，像宋小宝吃面那样，辣根和蒜瓣这些步骤都不能省。说实在的，因为需要彻底改变思路，写新程序很累，但我还是勉力完成了：
猛击阅读全文

有个传言流传很久了，说是如果你被歹徒胁迫去ATM取钱，不妨把密码倒着输，如123456输成654321，然后，ATM就会一边吐钱给你（为了防止歹徒翻脸攮你一刀），一边偷偷替你报警。

这个传言的虚假性挺明显的，不过就我所知，办公室里曾经有人，看到这消息时，兴奋地念给大家听，完全辱没了自己程序员的身份。最近一念忽然想起了搁笔已久的《程序员入伙书》，该继续往下写了。这一篇并不算是真正介绍编程语言或技巧的，而是作为《程序员入伙书——两个世界》的补充篇，帮助大家习惯计算机的思路。

即使不是学编程的读者，这篇文章也可以算是足够浅显的逻辑训练，教大家识别都市传说真伪的套路。

假如我是程序员，被客户——或者啥也不懂、就知道和客户沆瀣一气的销售员——要求设计这样一个ATM：正着输密码就心平气和地吐钱，倒着输密码就边吐钱边报警。

我的第一个问题就是：万一用户的密码是888888怎么办？（暴发户脑子不好使，就记得这种密码）或者稍微复杂些的：158851，你到银行输这个密码，取款机该不该报警？当场就把在办公室传这个消息的人们问趴下了，我想，给我布置这个任务的客户也只好收回成命。

接着再说点深的，我努力做到循序渐进，先易后难。

首先说的就是，这个传言有个过于简单的假设（请记住“过于简单”这个词，文章结尾要用），就是“银行知道客户密码，所以知道密码是反着输的”。山寨银行或者骗子银行可能真知道客户密码，但正规的银行一定不知道，理由有浅有深。

浅显的原因是，银行的老大也要存钱，银行老大一定不喜欢任何人——柜台、出纳、甚至机器——看到或记住他的密码。你可能会问为啥让机器记也不可以，因为机器是人类维护的。如果银行知道客户密码，知道底细的老大就不愿意在自家银行存钱，更不愿意把钱存到别家银行。平民百姓也倒罢了，那几个小钱有跟没有差不多，如果银行的任何角落里留有客户密码，那么越有钱的人越不敢把钱往银行里搁。

深一点的原因，是这样可以保护银行自己。虽然银行都很贪，也确实在拿着所有客户的银子胡来，他们却不敢偷具体客户的存款，非但不敢偷，甚至还要做到“想偷都偷不出”。这样，万一有人状告银行在系统地盗用客户密码，银行就可以向调查者公开源程序：你们看，我们的系统真的无法窃取或透露用户密码，所以任何用户的钱因为取款取丢了，都是他自己没看好密码，我们没有赔偿责任。

定理：胆敢存储用户密码的银行，一定无法开张、即使开张也倒闭得最快最惨。

所以，每当我看到老太太们费力地按了六个键之后问柜台：“我按的是441205么？”再补一句“就是我的生日。”我都禁不住打哆嗦：老太太你这是要害死小姑娘啊！人家真的没看见你的密码，也不想听见你说的。再说你自己耳朵背，就非得嚷这么大声啊？我听见你的密码，都起歹意了……

那观众就要问了：银行不知道我们的密码，那我们怎么取钱的？取款机怎么知道我们输对还是输错了？
猛击阅读全文

以前的几个章节里，大家一定常见到print(…)、range(…)、max(…)之类的结构，它们是什么呢？

它们叫函数。不用管这个名字听起来多么奇怪，和数学上的函数、方程的概念多么不同，先接受这个名字，后面我会说这个名字的来历。

比如说，我们在《程序在干什么？》一节的最后一段举过一个求平方根的例子，后来在《初涉算法》一节讲解过它。就拿这个程序为例，如果现在我想求(根号2 + 根号3) x (根号5 – 根号7)，该怎么写程序？

当然我们可以把这个例子复制粘贴四遍，第一遍求根号2，第二遍求根号3，第三遍求根号5，第四遍求根号七，然后用这四个中间结果算出最后的值。

这个思路能干活，可就是直觉太傻太啰嗦。四段程序只有喂给它们的数字的差别，实在是太浪费了。所以人们想，可以引入数学上的函数y = f(x)概念，定义好这个函数的公式（f）之后，把参数（x）喂给它，让同一段代码对参数进行运算，运算结果放在y里，这样岂不节约？

好主意！我们现在把求平方根的算法定义成一个函数：

>>> def mysqrt(n):
    high = max(1, n)
    low = 0
    while True:
        result = (high + low) / 2
        if abs(result * result - n)  < n * 1E-8:
            break
        if result * result > n:
            high = result
        else:
            low = result
    return result

>>>

这段程序里最关键的是第一行，以关键字def引导的函数名mysqrt，其后以括号包围要传递给这个函数的参数n，最后是冒号表示：以下的缩进内容是用来定义这个函数的算法。

最后一行return result也很重要，见到return语句时，程序就会返回到使用函数的那个位置，在相应的mysqrt(x)的地方，放上本次运行得到的result值。这个值被称为返回值。

说得再多不如实际做一次：
猛击阅读全文

从前我用过的程序示例里面，使用的数据都是分离的、独立的。就是说，每个常量和变量，各有各的用途，没有“我们是一伙的”这样的共性。而在现实世界里，成群结队地出现的数据是大多数。例如一架飞机上的旅客，一个班级的学生，奥运会的参赛国。

我见过的所有编程语言都有数组（Array，List）的概念，用来存储具有共同属性的批量数据。在Python里，数组用一对中括号包围的一群数据来表示，数据之间用逗号隔开。例如：

>>> countries = ['China', 'USA', 'Germany', 'Canada', 'Japan']
>>> countries[0]
'China'
>>> countries[3]
'Canada'
>>> countries[4]
'Japan'
>>> 

在这里，countries就是一个数组，它有五个元素（Element），每个元素都是一个字符串表示的国名。引用这些元素的时候，我们使用一个整数，来指明它在数组里的位置，这个整数叫做下标（Index）。和大家的习惯稍有差异的是，在Python里，当我们说“数组的第一个元素”时，我们用的下标是0，第二个元素的下标是1，第三个元素的下标是2，依此类推。所以上面的程序范例里面，countries[0]打印出来的是第一个国名China，第五个国名使用的下标是4。

如果你觉得这个规则挺怪异的，想一想这个问题：进入一座楼房，爬到一楼需要爬几层楼梯？爬到五楼需要爬几层楼梯？然后你就释然了，因为对于计算机来说，数组就像楼层，一楼就是它的第一个元素，其它的楼层都是相对于一楼的偏移量。英式英语里，一楼叫做Ground Floor，二楼叫做First Floor，三楼叫做Second Floor，这就是计算机式的思维。

C/C++、Python、Perl、Java、PHP等语言里，第一个元素都是用下标0来表示。FORTRAN、BASIC、PASCAL等语言里，第一个元素是用下标1来表示。这两种表示方法都是合理的，照顾不同人群的思维习惯。

在刚才这个数组里，使用countries[5]会看到什么？
猛击阅读全文

一口气写了十几章，轻松一下。

读者老爷可能有点昏沉了，说，这么多章节了，怎么还没见到一个Windows程序呢？咱们就写一个。

在Python Shell里按Ctrl-N（或者点File菜单，选New Window），在弹出的编辑窗口里输入——或者拷贝-粘贴也行，反正今天是“轻松一下”：

import tkinter
root = tkinter.Tk()
root.geometry('240x180')
root.title('hello, world')
tkinter.Label(root, text = "hello, world").pack(fill="both", expand=1)
root.mainloop()

按Ctrl-S（或者点File菜单，选Save），随意起个名字，存好文件之后按F5。

怎么样，看到Windows版的hello, world了吧？虽然看起来十分傻，但既然能写hello, world，就能写别的，就能放按钮，就能画图表，就能放菜单，能写一切能想出来的东西。要紧的不在于界面是什么，而在于理解漂亮的外表背后发生的事情。况且，就连这个漂亮的外表本身，也是由灰头土脸的程序写成的。

其实咱们早已看到过循环了，只是当时并没有要求大家看明白。

循环，就是让程序反复执行同一段代码。利用计算机速度快，脾气好，不怕麻烦的优势（这几点，人类确实比不上），也省得人们把相似的任务反复书写几百遍。

有两种循环，一种是事先预知要循环多少次的，一种事先不知道。这两种循环，咱们在《程序在干什么？》一章里见过。那里头讲过三个例子，第一个例子是从1加到100，我们都知道要循环100次。第二个例子是九九乘法表，我们知道要重复做9行，每行做N列（N等于当前的行数）。第三个例子是猜平方根，这个就不能实现确实要循环多少次了，只隐约觉得精度好过亿分之一就可以结束。

预知循环次数、知道每次循环时要喂什么数据给程序的，叫做for循环。for的意思是：对于（for）每次循环，使用这些值……

预先不知道循环次数，只知道循环的结束条件的，叫做while循环，意思是：当（while）某条件判断为真的情况下，反复执行这段程序……

其实for循环是while的一个特例，例如那个从1加到100的，下面的两段程序，一个用for，一个用while，得到的结果是一样的：

>>> total = 0
>>> for i in range(1, 101):
	total += i
	
>>> total
5050


>>> total = 0
>>> i = 1
>>> while i < = 100:
	total += i
	i += 1
	
>>> total
5050
>>> 

所以我们先讲while。在Python里，while的用法是：

while 条件判断表达式:
	做这个
	做那个
	东张西望

凹进去的这段程序，只要“条件判断表达式”为真（True），就会被反复执行。上面的累加例子里，只要i小于等于100，累加就会持续下去。

while太简单太直观了，没啥可说的，直接说for吧，for的用法是：
猛击阅读全文

在上一章介绍if-else时，我在结尾举了个程序优化的例子，里面用到了一个词：and，我答应会细细讲到它，现在这个章节就是。

if-else的执行过程是这样的：比如语句是if a > 3，那么它就会看，a大于3吗？如果a的当前值等于4，那么4 > 3这个表达式就会算出一个“真”值，if a > 3就成了if True。程序看到了if True，就决定执行这段程序。如果a等于2，它就会最终看到if False（“假”值），if False的结果就是使程序跳过这段代码，转而执行下一个判断。

做个实验，这个实验证明if True所对应的程序段会无条件执行，而if False所对应的，则铁定不执行：

>>> if True:
	print("I am in the True block")

	
I am in the True block
>>> if False:
	print("I am in the False block")

	
>>> 

True的意思是“真”，False的意思是“假”。数学上说的真命题、假命题，和这两个概念等价。

不是所有的条件判断都是a > 3这么简单的，有时需要把几个条件组合起来。例如“晚上如果停电，我就点蜡烛”这句话，等同于“如果到了晚上，并且停电，我就点蜡烛。”只有“晚上”和“停电”同时满足时，才会引起点蜡烛的动作。而如果是大白天、或者有电、或者既是大白天又有电，那就没必要点蜡烛了。“他夫妻俩都去，我就去”的意思是“他去，并且她去，我就去。”如果这小两口有一位不出席，我就未必去。

这个表达“两个条件同时满足，才能得到True”的词：“并且”，在Python里被写为and。and两边的值必须同时为True，才能得到True的结果，否则结果是False。

>>> True and True
True
>>> True and False
False
>>> False and True
False
>>> False and False
False
>>>

and对条件要求相当苛刻，相当于给了所有投票者一票否决权。另有一种要求不那么苛刻的，只要有一个投了赞成票，就绿灯放行。这种运算叫做“或者”，Python里写作or。

“两个人有一个好的，这架就打不起来。”这话的逻辑就是or。意思是说，如果张麻子是好的or王二狗是好的，甚至两个人都是好的，就不会打得头破血流。

1971年，副统帅说想动一动，周丞相说，如果想动一动，需要周、黄、吴、李四人同时下令。但李是副统帅家的人，把这话解释为，只要周黄吴李中有人下令，就可以动。于是山海关的那架三叉戟就动了，动静还挺大。

这个例子，就是本来应该用and的地方写了or，原本是“周同意 and 黄同意 and 吴同意 and 李同意”变成了“周同意 or 黄同意 or 吴同意 or 李同意”。把and和or用错，很多老程序员都可能会犯。众所周知，那架三叉戟后来掉下来了。这个故事告诉我们：and和or千万不能弄反，故意制造Bug就更要不得了。
猛击阅读全文

在《初涉算法》一章，我说过程序没什么神秘的，无非是做三件事：

1. 计算
2. 流程控制
3. 输入输出

关于基本的计算，前头几章已经讲过了。现在开始说说流程控制（Flow Control）。

流程控制是程序的核心价值。如果一段程序从头到尾平铺直叙，一条大路走到黑，就不好意思说自己是程序了，顶多是在打算盘。试想，如果没有流程控制，“从1累加到100”的任务就只能这样完成，老没劲了：

total = 0
total += 1
total += 2
total += 3
:
:
total += 99
total += 100

一个有趣的程序，一定有种种的岔路和转圈。读者可能会问：你不是说计算机不会思考，所有的行为都是已知的么？岔路的变数从何而来？俺回答：道路是已知的，走路的人是未知的。种种变数，来自于人类或其它机器的输入。例如你正在看这个页面，计算机不知道你下一步是往上翻屏、往下翻，还是关掉窗口。你的下一步动作是机器无法预知的，但计算机做好了应对你的任何操作的准备——只要你不掐电源。

下面我就开始介绍“岔路”了：如果这样，如果那样。

举个例子，Python有个功能叫max，如果你在Python Shell里写max(1, 3)按回车，max一定会回答“3”。我们看看，如果自己来写这个功能，程序是什么样的。尝试一下这个例子——在Python Shell下按Ctrl-N打开一个窗口，输入这段代码：
猛击阅读全文

赋值语句，就是把一个值搁到一个变量里的过程。

完成这个过程很简单，一个“=”足矣。打开Python，随意输入类似这样的语句：

>>> radius = 10
>>> pi = 3.1415926535897932
>>> circumference = radius * pi * 2
>>> circumference
62.83185307179586
>>> 

看看，几条赋值语句就把半径等于10的圆的周长求出来了，是不是很容易？这些语句当然可以简单地写成10 * 3.1415926535897932 * 2，这里演示的是思考的过程。

初学编程的人，容易在两件事上不习惯，我这里单列出来：

一、“=”不是“相等”的意思，而是“把等号右边的值算出来，放到等号左边的变量里去”。
二、赋值完成后，等号左边变量原有的值就被覆盖了，消失了，找不回来了。

这些要点，以前举例时说过或者暗示过，这次隆重重申一下。为了体会第一点，试试这段代码（以前的例子里挺常见的）：

>>> total = 0
>>> total = total + 3
>>> total
3
>>> total = total + 4
>>> total
7
>>> 

像total = total + 4这种代码，现在在我眼里，是再正常不过的东东，但刚学编程的时代，是每次一瞧心里都咯噔一下的，因为把“等式”两边各减去total，即得到0 = 4。这怎么可能？！现在看顺眼了，因为我现在明白这句话就是三个步骤：把total的值读出来放到一个运算器里，在这个运算器里加4，把运算器的结果放回到total里去。
猛击阅读全文

上次我们说到了简单数据，现在就要说说怎么烹饪这些数据。因为我们的示例语言是Python，所以这里的内容只能保证对Python完全正确，其它的语言会有相似内容，但不一定完全相同。不用担心，各种编程语言的要素其实是差不多的，学会一门语言的思路，其它的也能很快融会贯通。

适用于数字的运算符

+       -       *       **      /       //      %
< <      >>      &       |       ^       ~
<>       < =      >=      ==      !=

其中，第一行运算符是一般的数学运算，第二行是计算机特色的位运算（不用担心看不懂，后头会讲到），第三行是数值比较。

先说第一行：+和-都很直观，加减是也。*是乘法，因为计算机键盘上没有×号，所以拿星号表示。你会问为什么不用x来代替？我回答：因为x是一个英文字母，会被Python当作一个变量名。

**是乘方的意思，例如2**3等于8，2**-1等于0.5，2**0.5等于1.4142135623730951（即根号2）。你可能会如梦方醒地说，既然可以这么方便地求解一个数的平方根，为啥当初要写那么复杂的一个算法？俺一边躲闪着观众的飞石，一边说：一、那段程序的主要目的，是演示二分查找的算法。二、其实在计算机的芯片级指令里也并没有乘方功能，**运算符的简洁外表的背后，隐藏着泰勒级数展开的算法，不比我那段程序轻松。

/是除法。小时候如果在试卷上这么写，是会被扣分的。老师只允许用÷号，或者以分数形式表示。键盘上没有÷号，就只能用/了。

//是除法取整数商。注意它和/是不同的：3/2的结果是1.5，而3//2会把那个小数部分.5扣除，只留下1。同理，1//2等于0，而不是0.5。拿这个运算符算整数是安全的，而算实数要小心，例如你可以试试0.7//0.1，和《两个世界》一章里的计算结果是一样一样的：6，具体原因在那一章已经讲过了。

%是除法求余数，例如7%4等于3，3%2等于1，8%4等于0。这个运算符很实用，常用来判断一个数字能否被另一个数整除（余数为0），或者把随机数字限定在一个范围内（不需要十分懂下面这个例子）：

>>> import random
>>> random.random()
0.08662194959873759
>>> int(random.random() * 1E10) % 10
9
>>> int(random.random() * 1E10) % 10
5
>>> int(random.random() * 1E10) % 10
0
>>> int(random.random() * 1E10) % 10
4
>>> int(random.random() * 1E10) % 10
6
>>> int(random.random() * 1E10) % 10
2
>>> int(random.random() * 1E10) % 10
1
>>> int(random.random() * 1E10) % 10
8
>>> 

暂且跳过第二行的位运算，这些概念目前有点难，大部分情况下也用不着，先介绍第三行的比较运算吧。

<>       < =      >=      ==      !=

这六个运算符十分好理解，从左往右，分别是小于、大于、小于等于、大于等于、等于、不等于的意思。怎么样？很简单吧？计算机键盘上没有≤、≥、≠这些字符，所以用< =、>=、!=来代替，就和刚才说过的乘除法似的，比较好懂。对于==，就得多解释一下：为什么不用单个的=呢？因为单个的=被用来表示“赋值”的含义了。看下面和Python Shell的交流过程，来加深理解：
猛击阅读全文