《数据分析实战-托马兹.卓巴斯》读书笔记第11章--代理人基的模拟（加油站加油、电动车耗尽电量、狼-羊掠食）

python数据分析个人学习读书笔记-目录索引

 

 第11章涵盖了代理人基的模拟；我们模拟的场景有：加油站的加油过程，电动车耗尽电量以及狼——羊的掠食。

本章中，会学习以下技巧：
·使用SimPy模拟加油站的加油过程
·模拟电动车耗尽电量的场景
·判断羊群面对群狼时是否有团灭的风险

11.1导论

获取数据总是一件麻烦事：收集数据就很累，然后要提取需要的特征，还得费很多功夫。而且，收集过来的数据容易导致短视：你只看到眼前几片树叶，忽略了整个森林。
不过，某些情况下你可以进行模拟。当不可能观察每个局部时，或者想在多种情况下测试模型时，或者要验证假设时，模拟就很有用了。
很多书介绍了如何进行金融数据的模拟。本书中不打算这么做。相反，我们将集中精力关注代理人基模型。这种模拟创建了一个虚拟世界（或环境），我们可以将代理人放置其中。代理人几乎可以是你考虑的任何物体：在我们的模拟中，代理人会是加油站、车、充电站、羊或狼。在模拟中，代理人与代理人、代理人与环境都互相影响。
不过，非常有效的代理人基模拟有些局限。最主要的是代理人之间互动的局限；错失一个重要的行为可能就会导致错误的结论。比如，路上的司机总是遵守章法，这么一个假设就会导致一个结论，路上只需要一条车道，而在现实中，人们的行为是多种多样的，只有一条车道就会引发长长的拥堵。如果想进一步了解代理人基模型及其限制，我推荐这篇文章：http://ijcsi.org/papers/IJCSI-9-1-3-115-119.pdf。
本章将说一说如何用SimPy设计并运行模拟。

原作者强烈推荐SimPy官网上的建模介绍：https://simpy.readthedocs.org/en/latest/topical_guides/index.html。
你可以从http://pypi.python.org/pypi/SimPy/下载软件包。
如果你用的是Anaconda，可以使用下面的命令：

/* 
pip install -U simpy
*/

本章我们会接触Python更高深的部分：编写和继承类，以及使用异常中断模拟。别紧张，我们会详细讲解的。

/*
pip install simpy
Looking in indexes: https://pypi.tuna.tsinghua.edu.cn/simple
Collecting simpy
  Downloading https://pypi.tuna.tsinghua.edu.cn/packages/5a/64/8f0fc71400d41b6c2c6443d333a1cade458d23d4945ccda700c810ff6aae/simpy-3.0.11-py2.py3-none-any.whl
Installing collected packages: simpy
Successfully installed simpy-3.0.11
FINISHED
 */

11.2使用SimPy模拟加油站的加油过程

你如果有车，那去加油站就是常规活动了：取下泵，刷卡，加油，离开。
不过，如果你要建一个加油站，那就要提前考虑一系列问题了：
·车辆加油的频率是多少？
·这对每个司机的等待时长有什么样的影响？（我们可不希望有人因为等太久而去了竞争者那里）
·能不能满足需求？
·多久需要让供应商装满油箱？
·能产生多少利润？
这些问题都得问问自己。
还有那些如果。如果加两个加油机呢？如果用更大的油箱呢，这样不用经常叫供应商过来了？如果车辆来加油站的频率不是30秒一辆，二是45秒一辆呢？这会如何影响我的利润？
在你投入数百万之前，试试模拟，测试各种场景，这是一个便宜但宝贵的工具。
注意下，这个章节的流程和本书之前的不同。
准备：需要装好SimPy和NumPy。
代码实现：模拟的代码很长，但既然你书都看到这里了，对你来说，代码的逻辑应该是相当直接的。GitHub上的源代码——sim_gasStation.py文件——可能有些地方不清晰。我们下一节会一步一步地过一遍：

import numpy as np
import simpy
import itertools
if __name__ == '__main__':
# what is the simulation horizon (in seconds)
#模拟时限，以秒计 
SIM_TIME = 10 * 60 * 60 # 10 hours

# create the environment创建环境
env = simpy.Environment()

# create the gas station
gasStation = GasStation(env)

# print the header
print('\t\t\t\t\t\t     Left')
header =  'CarID\tArrive\tStart\tFinish\tGal'
header += '\tType\tPetrol\tDiesel'
print(header)
print('-' * 62)

# create the process of generating cars 生成车
env.process(Car.generate(env, gasStation))

# and run the simulation运行模拟 
env.run(until = SIM_TIME) 

原理：照例先引入需要的模块。
我们的代码以if__name__=='__main__'（这是Python的约定）。先决定模拟程序要跑多久。本例中，我们将一轮当成1秒。然后创建环境（.Environment（...））。这是模拟的基础。环境封装了时间，并处理模拟中代理人之间的互动。
下面，创建第一个代理人，GasStation：

class GasStation(object):
    '''
        Gas station class.
    '''
    def __init__(self, env):
        '''
            The main constructor of the class

            @param env -- environment object
        '''
        # keep a pointer to the environment in the class 保存一个指向环境的指针
        self.env = env

        # fuel capacity (gallons) and reservoirs
        # to track level
        #油箱（加仑）和贮油器
        self.CAPACITY = {'PETROL': 8000, 'DIESEL': 3000}
        self.RESERVOIRS = {}
        self.generateReservoirs(self.env, self.CAPACITY)

        # number of pumps for each fuel type 每种染料的泵数
        self.PUMPS_COUNT = {'PETROL': 3, 'DIESEL': 1}
        self.PUMPS = {}
        self.generatePumps(self.env, self.CAPACITY,
            self.PUMPS_COUNT)

        # how quickly they pump the fuel 抽出的速度
        self.SPEED_REFUEL = 0.3 # 0.3 gal/s

        # set the minimum amount of fuel left before
        # replenishing
        #设置在补足前的最少油量
        self.MINIMUM_FUEL = {'PETROL': 300, 'DIESEL': 100}

        # how long does it take for the track to get
        # to the station after placing the call        
        self.TRUCK_TIME = 200
        self.SPEED_REPLENISH = 5

        # add the process to control the levels of fuel
        # available for sale
        self.control = self.env.process(self.controlLevels())

        print('Gas station generated...')

Python中的类都有__init__（self，...）方法。创建GasStation对象时会调用这个方法。
你可以创建一个只有静态方法的类，那就不需要__init__（self，...）了。静态方法的执行不需要对象。也就是说，调用这个方法不依赖于任何对象的性质，但这个方法依然与类的主题有关。
比如，你有一个Triangle类，创建了使用勾股定理计算弦长的方法length。你也可以用这个方法计算平面上两点之间的距离（笛卡尔坐标系）。这时，你就可以将这个方法声明为静态的，并在需要时调用，以实现代码的重用。
你可能已经注意到了，self（几乎）出现在所有方法里。self参数是指向实例对象自身的引用（也由此得名）。
在__init__（self，...）方法内，你应该列出所有实例对象都会拥有的内部属性。我们的加油站会提供两种燃料：汽油和柴油。油箱分别可以容纳8000加仑和3000加仑。所以self.RESERVOIRS属性有两种.Container（...）：对应这两种燃料。.Container（...）对象其实就是许多处理过程可以共享的资源；每个过程都可以访问这个公用的源，直到结束，或.Container（...）中用光了。.generateReservoirs（...）方法实现了这些逻辑：

    def generateReservoirs(self, env, levels):
        '''
            Helper method to generate reservoirs
        '''
        for fuel in levels:
            self.RESERVOIRS[fuel] = simpy.Container(
                env, levels[fuel], init=levels[fuel])

.Container（...）方法以指向.Environment（...）对象的指针作为第一个参数，贮油器的容量作为第二个参数，初始量作为第三个参数。
用generatePumps（...）方法创建FuelPump对象：

    def generatePumps(self, env, fuelTypes, noOfPumps):
        '''
            Helper method to generate pumps 生成泵的辅助函数
        '''
        for fuelType in fuelTypes:
                self.PUMPS[fuelType] = FuelPump(
                    env, noOfPumps[fuelType])

FuelPump对象唯一的属性self.resource放的是SimPy的.Resource（...）对象。可以将.Resource（...）对象看成某种资源的守门员。可用来限制并行访问某种.Container（...）的过程的数目。
在我看来，区分.Container（...）和.Resource（...）的最简单办法是想想加油站的运转方式。同一个（地下）油箱连有多个贮油器。任何时候，一辆车可使用一个贮油器；所以加油站的吞吐量由贮油器的数目限定。这就是我们将FuelPump作为.Resource（...）的原因。另外，所有的贮油器都连接油箱，我们使用.Container（...）对象为这种行为建模。来了一辆车，我们使用.Resource（...）的.request（...）方法访问一个贮油器；如果所有的贮油器都被占用了，就得等待。
然后指定输油的速度——本例中是0.3 gal/s——以及重新装满前的最小油量；对于汽油，我们看到少于300加仑时就要叫油车来，对于柴油，这条线在100加仑。计算中也要考虑油车在路上花的时间（假设是300秒），以及5加仑每秒的速度下，重新充满需要的时间。
__init__（self，...）方法的最后一个指令创建环境中第一个过程；将.controlLevels（）方法放到环境中：

    def controlLevels(self):
        '''
            A method to check the levels of fuel (every 5s)
            and replenish when necessary
        '''
        while True:
            # loop through all the reservoirs 循环所有油箱
            for fuelType in self.RESERVOIRS:

                # and if the level is below the minimum
                #如果油量不是最小值
                if self.RESERVOIRS[fuelType].level \
                    < self.MINIMUM_FUEL[fuelType]:

                    # replenishes补满
                    yield env.process(
                        self.replenish(fuelType))
                # wait 5s before checking again--5秒后检查
                yield env.timeout(5)

这个方法在整个模拟期间持续循环。循环内使用yield env.timeout（5），每5秒检查油箱的量。
整个模拟期间，各种代理人都会创建与挂起过程。yield命令挂起过程，并在之后由环境或另一个过程唤起。我们的例子中，yield env.timeout（5）将当前过程挂起5秒；5秒后，环境会触发另一次遍历。
循环中，我们检查所有油箱是否不足最小量。如果不足，我们挂起过程，叫来油车，即replenish（...）方法。当前遍历只有在完成补充工作后才会恢复：

    def replenish(self, fuelType):
        '''
            A method to replenish the fuel
        '''
        # print nicely so we can distinguish when the truck
        # was called
        print('-' * 62)
        print('CALLING TRUCK AT {0:4.0f}s.' \
            .format(self.env.now))
        print('-' * 62)

        # waiting for the truck to come (lead time)等油车来
        yield self.env.timeout(self.TRUCK_TIME)

        # let us know when the truck arrived
        print('-' * 62)
        print('TRUCK ARRIVING AT {0:4.0f}s' \
            .format(self.env.now))

        # how much we need to replenish 要补多少
        toReplenish = self.RESERVOIRS[fuelType].capacity - \
            self.RESERVOIRS[fuelType].level

        print('TO REPLENISH {0:4.0f} GALLONS OF {1}' \
            .format(toReplenish, fuelType))
        print('-' * 62)

        # wait for the truck to dump the fuel into
        # the reservoirs 等油车补满
        yield self.env.timeout(toReplenish \
            / self.SPEED_REPLENISH)

        # and then add the fuel to the available one
        yield self.RESERVOIRS[fuelType].put(toReplenish)

        print('-' * 62)
        print('FINISHED REPLENISHING AT {0:4.0f}s.' \
            .format(self.env.now))
        print('-' * 62)

注意有些情况下，用\分隔的多行命令会报错。你可以将多行命令放进括号（...）来避免错误。
replenish（...）方法中，我们先挂起过程，等油车到达。等过程恢复时，我们看看要补充多少。.Container（...）对象有两个我们要调用的属性：.capacity和.level。.capacity属性返回的是油箱的容量，而.level属性返回的是当前的存量。差值就是要补充的量。知道了这个，又知道了输油的速度，我们就能算出要花多少时间。完成后，我们将量加到对应的种类上，并返回到调用函数。
最后，定义Car类：

class Car(object):
    '''
        Car class.
    '''
    def __init__(self, i, env, gasStation):
        '''
            The main constructor of the class

            @param i          -- consecutive car id
            @param env        -- environment object
            @param gasStation -- gasStation object
        '''
        # pointers to the environment and gasStation objects
        #指向环境和加油站对象的指针
        self.env = env
        self.gasStation = gasStation

        # fuel type required by the car 需要的燃油种类
        self.FUEL_TYPE = np.random.choice(
            ['PETROL', 'DIESEL'], p=[0.7, 0.3])

        # details about the car 车的明细
        self.TANK_CAPACITY = np.random.randint(12, 23) # gal
        
        # how much fuel left 剩余油量
        self.FUEL_LEFT = self.TANK_CAPACITY \
            * np.random.randint(10, 40) / 100

        # car id 车ID
        self.CAR_ID = i

        # start the refueling process 开始加油过程
        self.action = env.process(self.refuel())

我们的车需要特定的油，以及预先定义好的油箱容量。创建一个car对象时，会随机分配一个值作为剩余的油量——在油箱容量的10%到40%之间。
加油过程开始：

    def refuel(self):
        '''
            Refueling method
        '''
        # what's the fuel type so we request the right pump
        #燃油种类，以便我们请求正确的泵
        fuelType = self.FUEL_TYPE

        # let's get the pumps object对应的泵对象
        pump = gasStation.getPump(fuelType)

        # and request a free pump 请求空闲的泵
        with pump.request() as req:
            # time of arrival at the gas station到达加油站的时间
            arrive = self.env.now

            # wait for the pump等待泵
            yield req

            # how much fuel does the car need 需要多少燃油
            required = self.TANK_CAPACITY - self.FUEL_LEFT
            
            # time of starting refueling 开始加油的时间
            start = self.env.now
            yield self.gasStation.getReservoir(fuelType)\
                .get(required)

            # record the fuel levels记录油量
            petrolLevel = self.gasStation\
                        .getReservoir('PETROL').level
            dieselLevel = self.gasStation\
                        .getReservoir('DIESEL').level

            # and wait for it to finish等待结束
            yield env.timeout(required / gasStation \
                .getRefuelSpeed())

            # finally, print the details to the screen
            refuellingDetails = '{car}\t{tm}\t{start}'
            refuellingDetails += '\t{fin}\t{gal:2.2f}\t{fuel}'
            refuellingDetails += '\t{petrol}\t{diesel}'

            print(refuellingDetails \
                .format(
                    car=self.CAR_ID,
                    tm=arrive,
                    start=int(start),
                    fin=int(self.env.now),
                    gal=required, fuel=fuelType,
                    petrol=int(petrolLevel),
                    diesel=int(dieselLevel)
                )
            )

我们先从GasStation对象调用特定燃油的泵。燃油种类是我们之前创建的.Resource（...）：这个对象对每种燃油，都有对应的可用的泵的数目——汽油三个，柴油一个。每来一辆车，都用.request（...）对象访问泵。然后就等待请求完成。
一旦泵可用，就恢复执行了。我们先计算要加多少油，并开始加油过程。这个过程会挂起补足油所花的时间。
这样就是整个加油过程啦。
generate（...）静态方法在模拟过程中随机生成车（每5到45秒一辆）：

    @staticmethod
    def generate(env, gasStation):
        '''
            A static method to generate cars 生成车的静态方法
        '''
        # generate as many cars as possible during the 
        # simulation run在模拟过程中随机生成车
        for i in itertools.count():
            # simulate that a new car arrives between 5s 
            # and 45s 每5-45秒一辆
            yield env.timeout(np.random.randint(5, 45))
            
            # create a new car
            Car(i, env, gasStation)

我们用env.process（Car.generate（env，gasStation））命令将生成车的过程加到环境中。
如你所见，静态方法同对象方法不同，不需要self关键字。
最后调用.run（...）方法。until参数指定了模拟要跑多久。
一旦执行程序，你会看到类似这样的界面：

整个模拟中，你会看到油车何时被召唤，以及整个过程结束的时间：


更多：那利润呢？这里我们假设加油站，每加仑汽油是1.95美元买入、2.45美元卖出，柴油是1.67美元买入、2.23美元卖出。我们也加上了充满油箱的初始花费（sim_gasStation_alternative.py文件）：

        # cash registry 增加记账
        self.sellPrice = {'PETROL': 2.45, 'DIESEL': 2.23}
        self.buyPrice  = {'PETROL': 1.95, 'DIESEL': 1.67}
        self.cashIn = 0
        self.cashOut = np.sum(
            [ self.CAPACITY[ft] \
            * self.buyPrice[ft] 
            for ft in self.CAPACITY])
        self.cashLost = 0

在replenish（...）方法中，我们也加上了一行付费行为：

 　　# and pay for the delivery 增加付费行为
     self.pay(toReplenish * self.buyPrice[fuelType])

.pay（...）方法将金额加到（支付给供应商的）self.cashOut变量上。
我们也假设有些消费者，在等了一段时间后，会不耐烦走掉（假设是5分钟——参看下面代码中的waitedTooLong布尔变量）。最后，Car的refuel（...）方法就变成了这样：

    def refuel(self):
        '''
            Refueling method
        '''
        # what's the fuel type so we request the right pump
        fuelType = self.FUEL_TYPE

        # let's get the pumps object
        pump = gasStation.getPump(fuelType) 

        # and request a free pump
        with pump.request() as req:
            # time of arrival at the gas station
            arrive = self.env.now

            # wait for the pump
            yield req

            # how much fuel does the car need
            required = self.TANK_CAPACITY - self.FUEL_LEFT

            # how long have been waiting for
            waitedTooLong = self.env.now - arrive > 5 * 60

            if waitedTooLong:
                # leave一怒而去
                print('-' * 70)
                print('CAR {0} IS LEAVING -- WAIT TOO LONG'\
                    .format(self.CAR_ID)
                )
                print('-' * 70)
                gasStation.lost(required * self.gasStation\
                    .getFuelPrice(fuelType))
            else:
                # time of starting refueling
                start = self.env.now
                yield self.gasStation.getReservoir(fuelType)\
                    .get(required)

                # record the fuel levels
                petrolLevel = self.gasStation\
                            .getReservoir('PETROL').level
                dieselLevel = self.gasStation\
                            .getReservoir('DIESEL').level

                # and wait for it to finish
                yield env.timeout(required / gasStation \
                    .getRefuelSpeed())

                # time finished refueling
                fin = self.env.now

                # pay 付费
                toPay = required * self.gasStation\
                    .getFuelPrice(fuelType)
                self.gasStation.sell(toPay)

                yield env.timeout(np.random.randint(15, 90))

                # finally, print the details to the screen
                refuellingDetails  = '{car}\t{tm}\t{start}'
                refuellingDetails += '\t{fin}'
                refuellingDetails += '\t{gal:2.2f}\t{fuel}'
                refuellingDetails += '\t{petrol}\t{diesel}'
                refuellingDetails += '\t${pay:3.2f}'

                print(refuellingDetails \
                    .format(car=self.CAR_ID, tm=arrive, 
                        start=int(start), 
                        fin=int(self.env.now), 
                        gal=required, fuel=fuelType, 
                        petrol=int(petrolLevel), 
                        diesel=int(dieselLevel),
                        pay=toPay
                    )
                )

车辆等得太久，就会开走：

/*
----------------------------------------------------------------------
CAR 1776 IS LEAVING -- WAIT TOO LONG
----------------------------------------------------------------------
----------------------------------------------------------------------
CAR 1778 IS LEAVING -- WAIT TOO LONG
----------------------------------------------------------------------
CAR 1780 IS LEAVING -- WAIT TOO LONG
----------------------------------------------------------------------

......
 */

你也会看到我们往GasStation类中加了一些新方法，.getFuelPrice（...）和.sell（...）。这些是用于计算并记录燃油销售额的，.sell（...）将金额加到self.cashIn变量上。
在整个模拟结束后，我们要打印结果：

　 # 打印记账结果
   def printCashRegister(self):
        print('\nTotal cash in:   ${0:8.2f}'\
            .format(self.cashIn))
        print('Total cash out:  ${0:8.2f}'\
            .format(self.cashOut))
        print('Total cash lost: ${0:8.2f}'\
            .format(self.cashLost))
        print('\nProfit: ${0:8.2f}'\
            .format(self.cashIn - self.cashOut))
        print('Profit (if no loss of customers): ${0:8.2f}'\
            .format(self.cashIn - self.cashOut \
                + self.cashLost))

前面的方法产生如下输出：

可见，如果加油站有更多的贮油器，挣到的就能超过8500美元。根据这些模拟参数，头10个小时，利润只有154.74美元。模拟20个小时，利润涨到1943.06美元，但是损失的机会成本也上升到8508.01美元。看起来加油站需要更多的贮油器。

11.3模拟电动车耗尽电量的场景

电动车如今越来越流行。不过尽管廉价，这种车在长途旅行中使用却有些限制，至少半路充电是个问题。
本技巧中，我们将模拟电动车耗尽电量的场景。我们在路上随机放置充电站。并且，我们允许司机没充满电就开出车。
准备：需要装好SimPy和NumPy。
代码实现：和前一技巧类似，我们先定义环境和所有代理人（sim_recharge.py文件）：

import numpy as np
import simpy


if __name__ == '__main__':
    # what is the simulation horizon (in minutes)
    SIM_TIME = 10 * 60 * 60 # 10 hours

    # create the environment
    env = simpy.Environment()

    # create recharge stations
    rechargeStations = RechargeStation \
        .generateRechargeStations(SIM_TIME)

    # create the driver and the car
    driver = Driver(env)
    car = Car(env, driver, rechargeStations)

    # print the header
    print()
    print('-' * 30)
    print('Time\tBatt.\tDist.')
    print('-' * 30)

    # and run the simulation
    env.run(until = SIM_TIME)

原理：我们指定模拟的参数：最多10小时，只模拟一辆车。
首先，创建环境和充电站：

    @staticmethod
    def generateRechargeStations(simTime):
        '''
            A static method to create gas stations along
            the route. Gas stations are located every
            80 - 140 miles

            @param simTime -- time of the simulation
        '''
        # we assume an average speed of 35MPH to calculate
        # a maximum distance that might be covered during
        # the simulation timespan
        #假设速度为35MPH,计算模拟过程 中，最多开多远
        maxDistance = simTime / 60 * 35 * 2

        # generate the recharge stations 生成充电 站
        distCovered = 0
        rechargeStations = [RechargeStation(env, 0)]

        while(distCovered < maxDistance):
            nextStation = np.random.randint(80, 140)

            distCovered += nextStation
            rechargeStations.append(
                RechargeStation(env, distCovered))
        
        return rechargeStations

.generateRechargeStations（...）方法设置模拟的时间，并在路线上随机放置充电站。这个方法假设均速是35mph，计算模拟时间内最大的行驶距离。充电站之间的距离在80英里到140英里之间。
在这个模拟中，我们加入司机的概念。司机经过充电站时，如果无法保证能到下一个充电站，就会停下来。司机也有权力中断充电过程，直接开出。
drive（...）方法引入一个新概念——中断：

    def drive(self, car, timeToFullRecharge):
        '''
            Method to control how long the recharging
            is allow to last

            @param car -- pointer to the car
            @timeToFullRecharge -- minutes needed to full
                                   recharge
        '''
        # decide how long to allow the car to recharge
        #允许充电站充多久
        interruptTime = np.random.randint(50, 120)

        # if more than the time needed to full recharge
        # wait till the full recharge, otherwise interrupt
        # the recharge process earlier
        #如果足够充满点，就等到充满，否则提前中断
        yield self.env.timeout(int(np.min(
            [interruptTime, timeToFullRecharge])))

        if interruptTime < timeToFullRecharge:
            car.action.interrupt()

车停靠充电站后，司机可以中断充电，直接开走。这是由.drive（...）方法随机决定的。这个方法以Car对象作为第一个参数，充满电的时间作为第二个参数。如果生成的随机数大于充满需要的时间，那就等到充满。否则，充电过程就停止，继续旅途。

在SimPy中中断进程很直接——调用.interrupt（）方法即可。这会抛出一个异常。
模拟的大部分代码和处理都在Car类中。我们先定义car参数。在两种容量的电池中选择，70kWh或85kWh。电池的起始电量在80%到100%之间。.AVG_SPEED决定了能行驶多远，范围在36.4mph到49.2mph之间。消耗是以每英里kWh描述的；每100英里，34kWh到38kWh，换算下来大约是100mpg-e到89mpg-e（miles per gallon equivalent，每加仑等价英里数）。旅途之初，我们在位置0。
模拟从driving（...）方法内的过程开始：

    def driving(self):
        # updates every 15 minutes 每15分钟更新
        interval = 15

        # assuming constant speed -- how far the car travels
        # in each 15 minutes 假设匀速
        distanceTraveled = self.AVG_SPEED / 60 * interval

        # how much battery used to travel that distance共耗多少电量
        batteryUsed = distanceTraveled * self.AVG_ECONOMY

首先，我们看看电量能支持多远；如果电量不足0.0%，我们中断模拟，并给一个提示：

        while True:
            # update the location of the car 更新车的位置
            self.LOCATION += distanceTraveled

            # how much battery power left 剩余 电量
            batteryLeft = self.BATTERY_LEVEL \
                * self.BATTERY_CAPACITY - batteryUsed
            
            # update the level of the battery 更新电池电量 格数
            self.BATTERY_LEVEL = batteryLeft \
                / self.BATTERY_CAPACITY
            
            # if we run out of power -- stop 耗尽电量---终止
            if self.BATTERY_LEVEL <= 0.0:
                print()
                print('!~' * 15)
                print('RUN OUT OF JUICE...')
                print('!~' * 15)
                print()
                break

驾驶过程中，我们要看最近的两个充电站，检查最近的距离：

            # along the way -- check the distance to 在路上，查看两个最近的充电站
            # the next two recharge stations
            nearestRechargeStations = \
                [gs for gs in self.rechargeStations
                    if gs.LOCATION > self.LOCATION][0:2]

            distanceToNearest = [rs.LOCATION \
                - self.LOCATION
                for rs in nearestRechargeStations]

            # are we currently passing a recharging station?正经过一个充电站？
            passingRechargeStation = self.LOCATION \
                + distanceTraveled > \
                    nearestRechargeStations[0].LOCATION

            # will we get to the next one on the charge left?剩余电量能支撑到下一个充电站吗？
            willGetToNextOne = self.check(
                batteryLeft,
                nearestRechargeStations[-1].LOCATION)

如果正经过一个充电站（passingRechargeStation），我们可以选择停车，也可以选择看看剩余电量能不能支撑到下个充电站（willGetToNextOne）。如果不太可能，我们就停下来充电：

            if passingRechargeStation \
                and not willGetToNextOne:

                # the charging can be interrupted by the
                # driver 充电可由司机中断
                try:
                    # how long will it take to fully recharge?充满要多久？
                    timeToFullRecharge = \
                        (1 - self.BATTERY_LEVEL) \
                        / nearestRechargeStations[0] \
                          .RECHARGE_SPEED

                    # start charging开始充电
                    charging = self.env.process(
                        self.charging(timeToFullRecharge,
                            nearestRechargeStations[0] \
                            .RECHARGE_SPEED))

                    # and see if the driver will drive off
                    # earlier than the car is fully recharged 司机是否提前开走
                    yield self.env.process(self.driver \
                        .drive(self, timeToFullRecharge))

                # if the he/she does -- interrupt charging 如果提前了，-中断充电
                except simpy.Interrupt:

                    print('Charging interrupted at {0}' \
                        .format(int(self.env.now)))
                    print('-' * 30)

                    charging.interrupt()

            # update the progress of the car along the way
            toPrint = '{time}\t{level:2.2f}\t{loc:4.1f}'
            print(toPrint.format(time=int(self.env.now),
                level=self.BATTERY_LEVEL, loc=self.LOCATION))
            
            # and wait for the next update 等待下一次更新
            yield self.env.timeout(interval)

注意我们是如何用try-except包裹代码的；try的部分，我们先决定timeToFullRecharge，并开始充电。同时调用Driver对象（具体是drive（...）方法），开始决定这次充电命运的过程——中不中断？
假设不中断，charging（...）方法中try部分的代码会全部执行。注意我们充电是每秒增量式地更新电量，以应对中断：

    def charging(self, timeToFullRecharge, rechargeSpeed):
        '''
            Method to recharge the car
        '''
        # we are starting the recharge process 开始充电进程
        try:
            # let's print out to the screen when this
            # happens
            print('-' * 30)
            print('Charging at {0}'.format(self.env.now))

            # and keep charging (every minute)
            for _ in range(int(timeToFullRecharge)):
                self.BATTERY_LEVEL += rechargeSpeed
                yield self.env.timeout(1)

            # if the recharge process is not interrupted
            print('Fully charged...')
            print('-' * 30)

        # else -- just finish then
        except simpy.Interrupt:
            pass

如果过程被司机中断了，driving（...）方法中的异常会传到charging（...）。然后不做任何处理，再返回driving（...）的执行。
执行代码后，你会看到这样的输出：


如果中断充电，会有一条消息：


如果模拟中，车的电量耗尽了，你会看到这样的输出：

11.4判断羊群面对群狼时是否有团灭的风险

一个著名的代理人基模型就是羊-狼捕食的例子。
模型模拟两群动物：一块区域上共同生活的羊和狼。羊群食草补充能量。狼群捕食羊群得到能量。在区域内移动消耗能量。一旦哪个动物能量低于0，就死了。
本技巧中，我们将构建一个300×300的区域（网格）并（初始）填充6000只羊和200只狼。我们也引入继承的概念：我们将创建一个通用的Animal类，然后派生出Sheep类和Wolf类。背后的思想很简单：动物是有共性的（都要在区域上移动），我们就不用在两个地方重复同样的代码了。
准备：需要装好SimPy和NumPy。
代码实现：

本技巧的代码很长，但跟着逻辑走应该很清楚（sim_sheepWolvesPredation.py文件）：

import numpy as np
import simpy
import collections as col

if __name__ == '__main__':
    # create the environment 创建环境
    env = simpy.Environment()

    # create the plane 创建区域
    plane = Plane(env, LAND, GRASS_COVERAGE,
        INITIAL_SHEEP, INITIAL_WOLF)

    # print the header
    print('\tSheep\t\tDied\t\tWolves\t\tDied\t')
    print('T\tLive\tBorn\tEnergy\tEaten\tLive\tBorn\tEnergy')

    # and run the simulation 运行模拟
    env.run(until = SIM_TIME)

原理解释：和之前一样，我们先创建.Environment（）。
然后创建Plane对象，我们的神奇动物们要在上面散步（下面的代码经过了缩略）：

class Plane(object):
    '''
        Plane class
    '''
    def __init__(self, env, bounds, grassCoverage,
        sheep, wolves):
        '''
            Default constructor
        '''        
        # pointer to the environment
        self.env = env

        # bounds of the plane
        self.bounds = bounds

        # grass
        self.grassCoverage = grassCoverage
        self.grass = [
            [0  for _ in range(self.bounds[0])]
                for _ in range(self.bounds[1])
        ]

        # we keep track of eaten grass
        self.grassEatenIndices = col.defaultdict(list)

        # create the animals
        self.noOfSheep  = sheep
        self.noOfWolves = wolves

        self.sheep = []
        self.wolves = []

        # keep track of counts
        self.counts = {
            'sheep': {
                'count': 0,
                'died': {
                    'energy': 0,
                    'eaten': 0,
                    'age': 0,
                },
                'born': 0
            },
            'wolves': {
                'count': 0,
                'died': {
                    'energy': 0,
                    'age': 0,
                },
                'born': 0
            }
        }

        # generate the grass and animals 生成草和动物
        self.generateGrass()
        self.generateSheep()
        self.generateWolves()

        # and start monitoring and simulation processes 开始监控和模拟过程
        self.monitor = self.env.process(
            self.monitorPopulation())
        self.action = self.env.process(self.run())

Plane类生成区域并先种草；我们使用.generateGrass（）方法来实现绿化：

    def generateGrass(self):
        '''
            Method to populate the plane with grass
        '''
        # number of tiles on the plane 区域内单位面积的块数
        totalSize = self.bounds[0] * self.bounds[1]

        # how many of them will have grass当中有多少要种草
        totalGrass = int(totalSize * self.grassCoverage)

        # randomly spread the grass on the plane 在区域上随机种草
        grassIndices = sorted(
            choice(totalSize, totalGrass, replace=False))

        for index in grassIndices:
            row = int(index / self.bounds[0])
            col = index - (self.bounds[1] * row)

            self.grass[row][col] = 1

这个方法，基于模拟的参数，检查区域上有多少单位块要种草。然后使用NumPy的.random.choice（...）方法随机选择单位块。最后把草种上去。
下一步是生成动物：

    def generateSheep(self):
        '''
            Method to populate the plane with sheep
        '''
        # place the sheep randomly on the plane 随机放一些羊
        for _ in range(self.noOfSheep):
            pos_x = rint(0, LAND[0])
            pos_y = rint(0, LAND[1])
            energy = rint(*ENERGY_AT_BIRTH)

            self.sheep.append(
                Sheep(
                    self.counts['sheep']['count'],
                    self.env, energy, [pos_x, pos_y], self)
                )
            self.counts['sheep']['count'] += 1

我们先决定区域上Sheep的主要属性：放哪里，初始有多少能量。决定了之后，简单附加到self.sheep列表就可以。
在Python的循环里，如果你用不到i这种循环次数；那就直接改用_。
生成狼群的方式类似：

    def generateWolves(self):
        '''
            Method to populate the plane with wolves
        '''
        # place the wolves randomly on the plane 随机放一些狼
        for _ in range(self.noOfWolves):
            pos_x = rint(0, LAND[0])
            pos_y = rint(0, LAND[1])
            energy = rint(*ENERGY_AT_BIRTH)

            self.wolves.append(
                Wolf(
                    self.counts['wolves']['count'],
                    self.env, energy, [pos_x, pos_y], self)
                )

            self.counts['wolves']['count'] += 1

Sheep类和Wolf类都派生自Animal类；毕竟都是动物：

class Animal(object):
    '''
        Animal class
    '''
    def __init__(self, i, env, energy, pos, plane):
        '''
            Default constructor
        '''
        # attributes属性
        self.energy = energy
        self.pos = pos          # current position

        # is the animal still alive动物是否还活着
        self.alive = True
        self.causeOfDeath = None

        # when did the animal ate the last 上一顿是啥时候
        self.lastTimeEaten = 0

        # range of movements移动范围
        self.movements = [i for i in range(-50,51)]

        # pointer to environment and the plane 指向环境和区域的指针
        self.env = env
        self.plane = plane
        self.id = i

Animal类控制所有主要的（Sheep类和Wolf类共有的）性质：移动move（...）（及其位置），死亡die（...），以及检查死因——你可以查看动物是否存活isAlive（...）以及还有多少能量。显然，这些性质是所有动物共有的。Animal类还存储了所有动物都有的属性：位置、能量以及是否活着。
为了移动（move（...））动物，我们随机选择水平轴和垂直轴，并沿着这个方向移动：

    def move(self):
        '''
            Changing the animal's position
        '''
        # determining the horizontal and vertical moves决定水平轴和垂直轴
        h = choice(self.movements)
        v = choice(self.movements)

        # adjusting the position调整位置
        self.pos[0] += h
        self.pos[1] += v

        # making sure we do not go outside the predefined land确保没有越界
        self.pos[0] = np.min(
            [np.max([0, self.pos[0] - 1]), LAND[0] - 1]
        )

        self.pos[1] = np.min(
            [np.max([0, self.pos[1] - 1]), LAND[1] - 1]
        )

        # and subtracting the energy due to move减去移动消耗的能量
        self.energy -= (h+v) / 4

这个方法确保没有越界，也减去了移动消耗的能量。
Sheep类和Wolf类的不同点在于它们的食物——羊吃草（eatGrass（...））而狼吃羊（eatSheep（...））：

    def eatGrass(self):
        '''
            Sheep eat grass
        '''
        if self.plane.hasGrass(self.pos):
            # get the energy from grass 获得能量
            self.energy += ENERGY_FROM_GRASS
            self.lastTimeEaten = self.env.now

            # and flag that the grass has been eaten标记草已被吃
            self.plane.grassEaten(self.pos)

        if self.energy > 200:
            self.energy = 200

吃草的时候，我们先检查当前位置有没有。有的话，能量增加ENERGY_FROM_GRASS变量指定的数值。我们规定羊的能量不能超过200；毕竟不可能无限增长。我们会更新最近一次进食时间。这个时间会用来决定动物生存的概率；这里的想法就是，长时间不进食，死亡的可能性就上升了。
注意从Animal类派生Sheep（或Wolf）时，我们仍然使用self（比如self.energy），尽管逻辑是在父类（Animal类）中实现的。
而eatSheep（...）方法先获取当前位置所有的羊，并决定狼要吃多少只：

    def eatSheep(self):
        '''
            Wolves eat sheep
        '''
        # get the sheep at the particular position on the
        # plane获取当前位置所有的羊
        sheep = self.plane.getSheep(self.pos)
        
        # decide how many will be eaten决定狼要吃多少只
        howMany = np.random.randint(1,
            np.max([len(sheep), 2]))

        # and feast 盛宴
        for i, s in enumerate(sheep):
            # we're checking if the sheep is still alive
            # as the removal of sheep that died happens later
            if s.isAlive() and i < howMany:
                self.energy += s.getEnergy() / 20
                s.die('eaten')
                
        if self.energy > 200:
            self.energy = 200

        # update the time of the last meal更新最近一次进食时间
        self.lastTimeEaten = self.env.now

遍历Sheep对象，看羊是否还活着，活着的话，吃掉。狼获得了对应的能量，并限制在200个单位以内。
回到Plane对象，生成所有的动物后，我们开始模拟。
第一个过程是monitorPopulation（...）：

    def monitorPopulation(self):
        '''
            Process to monitor the population
        '''
        # the process checks for animals that run out of
        # energy and removes them from simulation检查并移除所有能量耗尽的动物
        while True:
            for s in self.sheep:
                if s.energy < 0:
                    s.die('energy')

            for w in self.wolves:
                if w.energy < 0:
                    w.die('energy')
            
            # clean up method 清理
            self.removeAnimalsThatDied()
                
            yield self.env.timeout(1)

这个方法遍历所有动物（包括Sheep和Wolf），检查能量水平；低于0就死了。当所有动物都标记过后，调用removeAnimalsThatDied（...）方法：

    def removeAnimalsThatDied(self):
        '''
            Clean up method for removing dead animals 清理死亡的动物
        '''
        # get all animals that are still alive and those
        # that died 列出活着的动物与死去的动物
        sheepDied = []
        wolvesDied = []

        sheepAlive = []
        wolvesAlive = []

        for s in self.sheep:
            if s.isAlive():
                sheepAlive.append(s)
            else:
                sheepDied.append(s)

        for w in self.wolves:
            if w.isAlive():
                wolvesAlive.append(w)
            else:
                wolvesDied.append(w)

        # keep only those that are still alive只保留还活着的
        self.sheep = sheepAlive
        self.wolves = wolvesAlive
        
        # while for those that died -- update why they died
        cod = {'energy': 0, 'eaten': 0, 'age': 0}
        for s in sheepDied:
            cod[s.getCauseOfDeath()] += 1

        for cause in cod:
            self.counts['sheep']['died'][cause] = cod[cause]

        cod = {'energy': 0, 'age': 0}
        for w in wolvesDied:
            cod[w.getCauseOfDeath()] += 1

        for cause in cod:
            self.counts['wolves']['died'][cause] = cod[cause]
 
        # and finally -- release the memory by deleting the
        # animal objects 释放内存
        for s in sheepDied:
            del s

        for w in wolvesDied:
            del w

该方法遍历所有动物，区分出是否还活着；活着的参加下一轮循环。最后删除对象是为了释放占据的内存。
另一个过程是主模拟循环，run（...）方法。这个方法控制模拟的流程：

 　　def run(self):
        '''
            Main loop of the simulation
        '''
        while True:
            # first, move the animals on the plane移动区域内的动物
            self.updatePositions()

            # and let them eat 进食
            self.eat()

            # then let's see how many of them will reproduce繁殖
            self.reproduceAnimals()

            # and keep track of the grass regrowth记录草的生长
            self.env.process(self.regrowGrass())

            # finally, print the telemetry to the screen
            toPrint = '{tm}\t{sheep_alive}\t{sheep_born}'
            toPrint += '\t{sheep_died_energy}'
            toPrint += '\t{sheep_died_eaten}'
            toPrint += '\t{wolves_alive}\t{wolves_born}'
            toPrint += '\t{wolves_died_energy}'


            print(toPrint.format(
                tm=int(self.env.now),
                sheep_alive=int(len(self.sheep)),
                sheep_born=self.counts['sheep']['born'],
                sheep_died_energy= \
                   self.counts['sheep']['died']['energy'],
                sheep_died_eaten= \
                    self.counts['sheep']['died']['eaten'],
                sheep_died_age= \
                    self.counts['sheep']['died']['age'],
                wolves_alive=int(len(self.wolves)),
                wolves_born=self.counts['wolves']['born'],
                wolves_died_energy= \
                    self.counts['wolves']['died']['energy'],
                wolves_died_age= \
                    self.counts['wolves']['died']['age'])
            )

            # and wait for another iteration等下一个轮回
            yield self.env.timeout(1)

 

模拟的每一次循环，所有动物都可以在区域内随意走动（一步）。updatePositions（...）方法遍历所有动物，调用move（...）方法：

    def updatePositions(self):
        '''
            Method to update the positions of animals
        '''
        for s in self.sheep:
            s.move()

        for w in self.wolves:

 

 
下一步是进食。类似地，这个方法遍历所有动物，对羊调用eatGrass（...）方法，对狼调用eatSheep（...）方法：

    def eat(self):
        '''
            Method to feed animals
        '''
        for s in self.sheep:
            s.eatGrass()

        for w in self.wolves:
            w.eatSheep()

吃饱之后，模拟会进行繁殖（reproduceAnimals（...））：

    def reproduceAnimals(self):
        '''
            Method to reproduce animals
        '''
        # counting the number of births
        births = {'sheep': 0, 'wolves': 0}

        # reproduce sheep
        for s in self.sheep:
            # determine if the animal will reproduce 是否愿意繁殖
            willReproduce = np.random.rand() < \
                (SHEEP_REPRODUCE * 3 / \
                    (self.env.now - s.lastTimeEaten + 1))

            # if will reproduce and is still alive --
            # give birth at the same position as the mother
            #如果愿意且活着，原地生一个
            if willReproduce and s.isAlive():
                energy = rint(*ENERGY_AT_BIRTH)
                self.sheep.append(
                    Sheep(self.counts['sheep']['count'],
                        self.env, energy,
                        s.getPosition(), self))

                # increase the overall count of sheep 增加羊的数量
                self.counts['sheep']['count'] += 1

                # and the birth counter
                births['sheep'] += 1

        # reproduce wolves
        for w in self.wolves:
            # determine if the animal will reproduce 是否愿意繁殖
            willReproduce = np.random.rand() < \
                ( WOLF_REPRODUCE / \
                    (self.env.now - w.lastTimeEaten  + 1))
            # if will reproduce and is still alive --
            # give birth at the same position as the mother
             #如果愿意且活着，原地生一个
            if willReproduce and w.isAlive():
                energy = rint(*ENERGY_AT_BIRTH)
                self.wolves.append(
                    Wolf(self.counts['wolves']['count'],
                        self.env, energy,
                        w.getPosition(), self))
                
                # increase the overall count of wolves增加狼的数量
                self.counts['wolves']['count'] += 1

                # and the birth counter
                births['wolves'] += 1
                        # update the counts variable
        for animal in births:
            self.counts[animal]['born'] = births[animal]

这方法遍历所有动物，并随机决定要不要生。繁殖后代的概率依赖于最近一次进食的时间：越久，可能性越低。如果愿意繁殖且活着，一个新的Sheep或Wolf会在原来的位置创建。
增加数量后，我们重新种草：

    def regrowGrass(self):
        '''
            Regrow the grass
        '''
        # time to regrow the grass长草的时间
        regrowTime = 2
        yield self.env.timeout(regrowTime)
        
        # then we make the grass available at the position标记这个位置有草
        for pos in self.grassEatenIndices[
            self.env.now - regrowTime]:
            self.grass[pos[0]][pos[1]] = 1

regrowGrass（...）方法遍历吃过的所有位置，并重新长草。Sheep吃草后，.grass变量设为0，表示草被吃掉了，这个位置也加到.grassEatenIndices defaultdict对象里，这个对象记录每个位置草被吃掉的时间。这样，你可以调整regrowTime，看看对羊群数量有什么影响。
执行代码后，你会看到类似的输出：

T是模拟的时间，Live是存活的动物数目，Born是出生数，Died记录多少动物已死亡——也许是由于能量不足，（就Sheep而言）也许是由于被吃了。

 

第11章完。整书完。

略微休息，计划读下一本书《python数据分析（第2版）-阿曼多.凡丹戈》。

该书是一本介绍如何用Python进行数据分析的学习指南。全书共12章，从Python程序库入门、NumPy数组和Pandas入门开始，陆续介绍了数据的检索、数据加工与存储、数据可视化等内容。同时，本书还介绍了信号处理与时间序列、应用数据库、分析文本数据与社交媒体、预测性分析与机器学习、Python生态系统的外部环境和云计算、性能优化及分析、并发性等内容。在本书的最后，还采用3个附录的形式为读者补充了一些重要概念、常用函数以及在线资源等重要内容。

 

python数据分析个人学习读书笔记-目录索引

 

随书源码官方下载：
http://www.hzcourse.com/web/refbook/detail/7821/92