python编程导论_第九课随机游走

学习安排（8月7日-8月8日）
1.主要学习视频Week2
链接（http://www.xuetangx.com/courses/MITx/6_00_2x/2014_T2/courseware/d39541ec36564a88af34d319a2f16bd7/）
2.辅助内容：教材第14章随机游走与数据可视化

一个过程，如果它的下一个状态依赖于一些随机因素，那么这个过程就是随机的。随机过程的结果通常是不确定的，因此，我们很少对随机过程的行为做出明确描述，而是对它可能的行为做出概率上的描述。我们将重点介绍如何编写程序来帮助理解不确定的情况，很多这种程序都是模拟模型。

模拟模型会模仿实际系统的活动。我们可以将代码看作一种实验设备，称为模拟模型。它可以提供一些有价值的信息，这些信息是关于被模拟系统的可能的行为的。除此之外，模拟模型还经常用于预测一个实体系统的未来状态（如50年后的地球温度），或者替代那些昂贵的、费时的或非常危险的实体实验（如修改税法带来的影响）。

随机游走

布朗运动是随机游走的一种。随机游走广泛应用于对物理过程 （如扩散） 、生物过程（如DNA在异源双链中替换RNA的动力学过程）和社会过程（如股市走向）的建模。

我们之所以要在本章介绍随机游走，有如下三个原因。

• 从本质上说，随机游走非常有趣，而且应用广泛。
• 它为我们提供了一个非常好的示例来学习如何使用抽象数据类型和继承。我们一般使用抽象数据类型和继承对程序进行结构化，一个特别的用处是进行模拟建模。
• 它为我们提供了一个非常好的机会来学习更多Python语言特性，并可以演示一些生成图形的技术。

醉汉游走

我们来研究一个真正涉及行走的随机游走问题。一个酩酊大醉的农夫站在一片田地的正中央，他每秒钟都会向一个随机的方向迈出一步。那么1000秒之后，他与原点的期望距离是多少？如果他走了很多步，那么会离原点越来越远，还是更可能一遍又一遍地走回原点，并停留在附近？我们编写一个模拟模型来找出答案。

开始这个设计过程时，我们应该先设计一些数据抽象，帮助建立这个模拟模型，这些数据抽象也可能应用于其他类型的随机游走过程的模拟。一般来说，我们开发出的新数据类型应该对应于建模情形中出现的对象。这个情形中有3个明显的类型：Location、Field和Drunk。我们介绍实现这些类型的类时，你应该思考每个类在我们即将建立的模拟模型中会起到什么作用。

class Location(object):
   def __init__(self, x, y):
       """x and y are floats"""
       self.x = x
       self.y = y
       
   def move(self, deltaX, deltaY):
       """deltaX and deltaY are floats"""
       return Location(self.x + deltaX, self.y + deltaY)
   
   def getX(self):
       return self.x
   
   def getY(self):
       return self.y
   
   def distFrom(self, other):
       ox = other.x
       oy = other.y
       xDist = self.x - ox
       yDist = self.y - oy
       return (xDist**2 + yDist**2)**0.5
   
   def __str__(self):
       return '<' + str(self.x) + ', ' + str(self.y) + '>'

#这个类的作用是将醉汉与位置进行映射。它对位置没有限制，所以可以认为Field的范围是无限的。
#它允许将多个醉汉以位置随机的方式添加到一个Field对象中
class Field(object):
   def __init__(self):
       self.drunks = {}
       
   def addDrunk(self, drunk, loc):
       if drunk in self.drunks:
           raise ValueError('Duplicate drunk')
       else:
           self.drunks[drunk] = loc
           
   def moveDrunk(self, drunk):
       if not drunk in self.drunks:
           raise ValueError('Drunk not in field')
       xDist, yDist = drunk.takeStep()
       currentLocation = self.drunks[drunk]
       #use move method of Location to get new location
       self.drunks[drunk] = currentLocation.move(xDist, yDist)
       
   def getLoc(self, drunk):
       if not drunk in self.drunks:
           raise ValueError('Drunk not in field')
       return self.drunks[drunk]


import random

class Drunk(object):
   def __init__(self, name):
       self.name = name
   def __str__(self):
       return 'This drunk is named ' + self.name

#UsualDrunk类定义了醉汉在田地中游走的方式
#stepChoices的值限制了每一步都是一个长度单位，并且必须平行于X轴或Y轴    
class UsualDrunk(Drunk):
   def takeStep(self):
       stepChoices = [(0.0,1.0), (0.0,-1.0), (1.0, 0.0), (-1.0, 0.0)]
       return random.choice(stepChoices)

下一步就是使用这些类建立一个模拟模型来回答最初的问题。下面代码给出了模型中使用的3个函数。

函数walk模拟了numSteps步的一次游走。函数simWalks调用walk模拟numTrials次游走，每次numSteps步。函数drunkTest调用simWalks模拟多次不同长度的游走。

simWalks的参数dClass是一个class类型，用于在函数的第一行代码中创建一个合适的Drunk子类。然后，从Field.moveDrunk中调用drunk.takeStep时，会自动选择相应子类中的方法。

def walk(f, d, numSteps):
"""假设f是一个Field对象， d是f中的一个Drunk对象， numSteps是正整数。
将d移动numSteps次；返回这次游走最终位置与开始位置之间的距离"""
    start = f.getLoc(d)
    for s in range(numSteps):
        f.moveDrunk(d)
    return(start.distFrom(f.getLoc(d)))

def simWalks(numSteps, numTrials):
"""假设numSteps是非负整数， numTrials是正整数，
dClass是Drunk的一个子类。
模拟numTrials次游走，每次游走numSteps步。
返回一个列表，表示每次模拟的最终距离"""
    homer = UsualDrunk('Homer')
    origin = Location(0, 0)
    distances = []
    for t in range(numTrials):
        f = Field()
        f.addDrunk(homer, origin)
        distances.append(walk(f, homer, numSteps))
    return distances

def drunkTest(numTrials = 20):
"""假设walkLengths是非负整数序列，numTrials是正整数， dClass是Drunk的一个子类，
对于walkLengths中的每个步数，运行numTrials次simWalks函数，并输出结果"""
    for numSteps in [10, 100, 1000, 10000]:
        distances = simWalks(numSteps, numTrials)
        print 'Random walk of ' + str(numSteps) + ' steps'
        print ' Mean =', sum(distances)/len(distances)
        print ' Max =', max(distances), 'Min =', min(distances)

#讨厌寒冷，喜欢温暖的农夫，向南方进行随机移动时的速度是其他方向的两倍
class ColdDrunk(Drunk):
    def takeStep(self):
    stepChoices = [(0.0,1.0), (0.0,-2.0), (1.0, 0.0),\
(-1.0, 0.0)]
    return random.choice(stepChoices)

#一个喜欢阳光的醉汉，总是向着太阳移动（上午向东，下午向西）
class EWDrunk(Drunk):
    def takeStep(self):
    stepChoices = [(1.0, 0.0), (-1.0, 0.0)]
    return random.choice(stepChoices)

def simAll(drunkKinds, walkLengths, numTrials):
    for dClass in drunkKinds:
    drunkTest(walkLengths, numTrials, dClass)

simAll((UsualDrunk, ColdDrunk, EWDrunk), (100, 1000), 10)

这些模拟就其本身来说不是特别有趣，但有如下几点值得我们借鉴。

• 首先，我们将模拟代码分成了4个独立的部分。其中3个为类（Location、 Field和Drunk），对应于问题非正式描述中出现的3个抽象数据类型。第4部分是一组函数，可以使用这些类进行一些简单的模拟。
• 然后，我们为Drunk类精心设计了一个层次结构，这样可以观察各种不同类型的有偏随机游走。关于Location和Field的代码依然保持不变，但修改了模拟代码来遍历Drunk的不同子类。在此期间，我们利用了“类本身也是一个对象”这一特点，将其作为实参进行传递。
• 最后，我们对模拟过程进行了一系列增量修改，但其中没有任何修改涉及表示抽象类型的类。这些修改多数是为了生成图形，这些图形可以使我们对不同类型的游走有更深刻的理解。这是一种典型的开发模拟模型的方法，先使基础的模拟运行起来，然后不断添加新功能。