12 Random walks: three small classes, one walk function, and the numbers and pictures that come out of running it many times

counting all sixteen two step walks, to see whether they cancel

The cancelling argument says the mean distance should be zero, and two steps is small enough to settle by counting.

Each step is one of four, so two steps make sixteen walks, all equally likely. Group them by where they end.

The program below builds the same sixteen walks and prints the group sizes and the mean:

stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
distances = []
for first in stepChoices:
    for second in stepChoices:
        x = first[0] + second[0]
        y = first[1] + second[1]
        distances.append((x**2 + y**2)**0.5)
home = distances.count(0.0)
far = distances.count(2.0)
print('walks:', len(distances))
print('came home:', home)
print('two away:', far)
print('mean:', format(sum(distances) / len(distances), '.4f'))

It prints:

walks: 16
came home: 4
two away: 4
mean: 1.2071

five steps out of a seeded stream

The first thing to see is what one call actually hands back. This program seeds the generator, then asks for five steps:

import random

stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
random.seed(4)
for s in range(5):
    print(random.choice(stepChoices))

It prints:

(0, -1)
(1, 0)
(0, 1)
(-1, 0)
(-1, 0)

Five pairs, and they are pairs rather than numbers: the second one goes east, the third north. The same seed gives the same five on the same interpreter, which is what makes a page like this one checkable.

one move, and what is left behind

The class as this course writes it, with one move and three questions asked of the result:

class Location(object):

    def __init__(self, x, y):
        """x and y are numbers"""
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        """Hands back a NEW Location deltaX, deltaY away from this one"""
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def distFrom(self, other):
        """Straight line distance from this place to other"""
        xDist = self.x - other.getX()
        yDist = self.y - other.getY()
        return (xDist**2 + yDist**2)**0.5

    def __repr__(self):
        return '<' + str(self.x) + ', ' + str(self.y) + '>'


start = Location(0, 0)
here = start.move(0, 1)
print(start, here)
print(start.distFrom(here))
print(here is start)

It prints:

<0, 0> <0, 1>
1.0
False

The third line is the one worth pausing on. here and start are different objects, so the distance between them is not zero, and the place saved in start is still usable as a measuring point.

the mutating version, and the two names it ruins

The same class with the counterexample's move in it, and two names pointing at one place:

class BadLocation(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        self.x = self.x + deltaX
        self.y = self.y + deltaY
        return self

    def __repr__(self):
        return '<' + str(self.x) + ', ' + str(self.y) + '>'


origin = BadLocation(0, 0)
homer = origin
marge = origin
homer = homer.move(1, 0)
print(homer, marge, origin)
print(homer is marge)

It prints:

<1, 0> <1, 0> <1, 0>
True

One object was built and three names hold it, so the single move shows up in all three. Nothing raised an error, and this is what makes the mutating version dangerous rather than merely wrong.

a field, a scripted walker, and two moves

The field's three methods, driven by a walker whose steps are known in advance so that the output can be predicted. The step list cycles, so this walker goes east, north, east, north:

class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def __repr__(self):
        return '<' + str(self.x) + ', ' + str(self.y) + '>'


class Field(object):
    """A dictionary from a drunk to the place that drunk is standing on."""

    def __init__(self):
        self.drunks = {}

    def addDrunk(self, d, loc):
        self.drunks[d] = loc

    def getDrunks(self):
        return self.drunks

    def moveDrunk(self, drunk):
        if drunk not in self.drunks:
            print('Drunk not in field')
        else:
            xDist, yDist = drunk.takeStep()
            currentLocation = self.drunks[drunk]
            self.drunks[drunk] = currentLocation.move(xDist, yDist)

    def getLoc(self, drunk):
        if drunk not in self.drunks:
            print('Drunk not in field')
        else:
            return self.drunks[drunk]


class ScriptedDrunk(object):

    def __init__(self, name, steps):
        self.name = name
        self.steps = steps
        self.next = 0

    def takeStep(self):
        step = self.steps[self.next % len(self.steps)]
        self.next = self.next + 1
        return step

    def __repr__(self):
        return self.name


f = Field()
tester = ScriptedDrunk('Tester', [(1, 0), (0, 1)])
f.addDrunk(tester, Location(0, 0))
print(f.getLoc(tester))
f.moveDrunk(tester)
f.moveDrunk(tester)
print(f.getLoc(tester))
print(f.getDrunks())

It prints:

<0, 0>
<1, 1>
{Tester: <1, 1>}

The last line is the field's own dictionary, printed as it is. Both the key and the value print readably because both classes define __repr__.

two keys sharing one place, and only one of them moving

The sharing question, in a dictionary small enough to print. Two names are stored under two keys and both hold the same Location object:

class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def __repr__(self):
        return '<' + str(self.x) + ', ' + str(self.y) + '>'


origin = Location(0, 0)
places = {}
places['Homer'] = origin
places['Marge'] = origin
print(places['Homer'] is places['Marge'])
places['Homer'] = places['Homer'].move(1, 0)
print(places)
print(origin)

It prints:

True
{'Homer': <1, 0>, 'Marge': <0, 0>}
<0, 0>

The first line proves they really do share, and the last proves that the shared place came through the move untouched.

a scripted walk of four steps, and a walk of none

The function, driven by a walker whose steps repeat east, north, east, north, so that the answer is known before the program runs:

class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def distFrom(self, other):
        xDist = self.x - other.getX()
        yDist = self.y - other.getY()
        return (xDist**2 + yDist**2)**0.5

    def __repr__(self):
        return '<' + str(self.x) + ', ' + str(self.y) + '>'


class Field(object):

    def __init__(self):
        self.drunks = {}

    def addDrunk(self, d, loc):
        self.drunks[d] = loc

    def moveDrunk(self, drunk):
        xDist, yDist = drunk.takeStep()
        self.drunks[drunk] = self.drunks[drunk].move(xDist, yDist)

    def getLoc(self, drunk):
        return self.drunks[drunk]


class ScriptedDrunk(object):

    def __init__(self, name, steps):
        self.name = name
        self.steps = steps
        self.next = 0

    def takeStep(self):
        step = self.steps[self.next % len(self.steps)]
        self.next = self.next + 1
        return step

    def __repr__(self):
        return self.name


def walk(f, d, numSteps):
    """Assumes f a Field, d a drunk in f, numSteps an int >= 0.
       Moves d numSteps times and returns the straight line distance
       between where d ended and where d started."""
    start = f.getLoc(d)
    for s in range(numSteps):
        f.moveDrunk(d)
    return start.distFrom(f.getLoc(d))


f = Field()
tester = ScriptedDrunk('Tester', [(1, 0), (0, 1), (1, 0), (0, 1)])
f.addDrunk(tester, Location(0, 0))
print(walk(f, tester, 4))
print(f.getLoc(tester))
f.addDrunk(tester, Location(0, 0))
print(walk(f, tester, 0))

It prints:

2.8284271247461903
<2, 2>
0.0

The first line is the raw float. Python prints every digit it has when nothing formats the value, and 2.8284271247461903 is what a square root of 8 looks like when it is printed unformatted.

the same function with two lines swapped

What happens when the starting place is read after the loop rather than before it. Everything else is identical, and the walker really does move:

class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def distFrom(self, other):
        xDist = self.x - other.getX()
        yDist = self.y - other.getY()
        return (xDist**2 + yDist**2)**0.5


class Field(object):

    def __init__(self):
        self.drunks = {}

    def addDrunk(self, d, loc):
        self.drunks[d] = loc

    def moveDrunk(self, drunk):
        xDist, yDist = drunk.takeStep()
        self.drunks[drunk] = self.drunks[drunk].move(xDist, yDist)

    def getLoc(self, drunk):
        return self.drunks[drunk]


class ScriptedDrunk(object):

    def __init__(self, name, steps):
        self.name = name
        self.steps = steps
        self.next = 0

    def takeStep(self):
        step = self.steps[self.next % len(self.steps)]
        self.next = self.next + 1
        return step


def brokenWalk(f, d, numSteps):
    for s in range(numSteps):
        f.moveDrunk(d)
    start = f.getLoc(d)
    return start.distFrom(f.getLoc(d))


f = Field()
tester = ScriptedDrunk('Tester', [(1, 0), (0, 1)])
f.addDrunk(tester, Location(0, 0))
print(brokenWalk(f, tester, 10))
print(f.getLoc(tester).getX(), f.getLoc(tester).getY())

It prints:

0.0
5 5

Zero, for a walk that took ten steps and ended 7.07 away. The second line is there to prove the walking happened: the walker is standing at 5, 5.

the three cheap tests: zero steps, one step, two steps

Before believing a simulation, run it on the cases whose answers are known. This program collects every distance that appears over a hundred walks, for walks of zero, one and two steps:

import random


class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def distFrom(self, other):
        xDist = self.x - other.getX()
        yDist = self.y - other.getY()
        return (xDist**2 + yDist**2)**0.5


class Field(object):

    def __init__(self):
        self.drunks = {}

    def addDrunk(self, d, loc):
        self.drunks[d] = loc

    def moveDrunk(self, drunk):
        xDist, yDist = drunk.takeStep()
        self.drunks[drunk] = self.drunks[drunk].move(xDist, yDist)

    def getLoc(self, drunk):
        return self.drunks[drunk]


class UsualDrunk(object):

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        return random.choice(stepChoices)


def walk(f, d, numSteps):
    start = f.getLoc(d)
    for s in range(numSteps):
        f.moveDrunk(d)
    return start.distFrom(f.getLoc(d))


def distancesSeen(numSteps, numTrials):
    """The set of distances a walk of numSteps ever produces in numTrials"""
    seen = []
    d = UsualDrunk()
    for t in range(numTrials):
        f = Field()
        f.addDrunk(d, Location(0, 0))
        dist = walk(f, d, numSteps)
        if dist not in seen:
            seen.append(dist)
    seen.sort()
    return seen


random.seed(7)
print(distancesSeen(0, 100))
print(distancesSeen(1, 100))
print(distancesSeen(2, 100))

It prints:

[0.0]
[1.0]
[0.0, 1.4142135623730951, 2.0]

The third line is the interesting one. Two steps can end 1.41 away, which the naive guess of nothing or two misses, and it is the group of eight corner walks counted at the start of this section.

ten walks of a hundred steps, reported three ways

The trial loop, with the ten distances printed one per line and then the three report numbers:

import random


class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def distFrom(self, other):
        xDist = self.x - other.getX()
        yDist = self.y - other.getY()
        return (xDist**2 + yDist**2)**0.5


class Field(object):

    def __init__(self):
        self.drunks = {}

    def addDrunk(self, d, loc):
        self.drunks[d] = loc

    def moveDrunk(self, drunk):
        xDist, yDist = drunk.takeStep()
        self.drunks[drunk] = self.drunks[drunk].move(xDist, yDist)

    def getLoc(self, drunk):
        return self.drunks[drunk]


class UsualDrunk(object):

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        return random.choice(stepChoices)


def walk(f, d, numSteps):
    start = f.getLoc(d)
    for s in range(numSteps):
        f.moveDrunk(d)
    return start.distFrom(f.getLoc(d))


def simWalks(numSteps, numTrials):
    """Runs numTrials walks of numSteps and returns the list of distances"""
    homer = UsualDrunk()
    origin = Location(0, 0)
    distances = []
    for t in range(numTrials):
        f = Field()
        f.addDrunk(homer, origin)
        distances.append(walk(f, homer, numSteps))
    return distances


random.seed(3)
distances = simWalks(100, 10)
for dist in distances:
    print(format(dist, '.1f'))
mean = sum(distances) / len(distances)
print('Mean:', format(mean, '.2f'))
print('Max:', format(max(distances), '.2f'))
print('Min:', format(min(distances), '.2f'))

It prints:

5.8
15.3
15.3
8.6
5.7
10.2
13.9
4.5
2.0
3.2
Mean: 8.44
Max: 15.30
Min: 2.00

The mean is 8.44 and no single walk reported that. The closest was 8.6, the two extremes were 2.0 and 15.3, and that spread of 13.3 is more than one and a half times the mean.

one walk against five hundred walks

The same drunk, the same hundred steps, asked three times. The first two are single walks and the third is the mean of five hundred:

import random


class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def distFrom(self, other):
        xDist = self.x - other.x
        yDist = self.y - other.y
        return (xDist**2 + yDist**2)**0.5


class UsualDrunk(object):

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        return random.choice(stepChoices)


def oneWalk(d, numSteps):
    start = Location(0, 0)
    here = start
    for s in range(numSteps):
        xDist, yDist = d.takeStep()
        here = here.move(xDist, yDist)
    return start.distFrom(here)


random.seed(31)
homer = UsualDrunk()
print('first walk  ', format(oneWalk(homer, 100), '.1f'))
print('second walk ', format(oneWalk(homer, 100), '.1f'))
total = 0
for t in range(500):
    total = total + oneWalk(homer, 100)
print('mean of 500 ', format(total / 500, '.1f'))

It prints:

first walk   6.0
second walk  11.0
mean of 500  8.6

The two single walks differ by almost a factor of two. Either one of them, written down alone, would look like a measurement.

what the reset actually protects, measured both ways

The reset is easy to drop, and dropping it does not make the distances look wrong, which is why it needs measuring rather than arguing about. This program runs four trials twice, once with the reset and once without, and prints two distances for each trial: from where that trial started, and from the origin of the whole run:

import random


class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def distFrom(self, other):
        xDist = self.x - other.getX()
        yDist = self.y - other.getY()
        return (xDist**2 + yDist**2)**0.5


class Field(object):

    def __init__(self):
        self.drunks = {}

    def addDrunk(self, d, loc):
        self.drunks[d] = loc

    def moveDrunk(self, drunk):
        xDist, yDist = drunk.takeStep()
        self.drunks[drunk] = self.drunks[drunk].move(xDist, yDist)

    def getLoc(self, drunk):
        return self.drunks[drunk]


class UsualDrunk(object):

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        return random.choice(stepChoices)


def trial(f, d, numSteps, origin, reset):
    """One trial. Returns the distance walked from where this trial
       started, and the distance from the origin of the whole run."""
    if reset:
        f.addDrunk(d, origin)
    start = f.getLoc(d)
    for s in range(numSteps):
        f.moveDrunk(d)
    end = f.getLoc(d)
    return start.distFrom(end), origin.distFrom(end)


def fourTrials(reset):
    random.seed(3)
    d = UsualDrunk()
    origin = Location(0, 0)
    f = Field()
    f.addDrunk(d, origin)
    for t in range(4):
        fromStart, fromOrigin = trial(f, d, 100, origin, reset)
        print('  trial', t + 1, 'from start', format(fromStart, '.1f'),
              'from origin', format(fromOrigin, '.1f'))


print('with the reset')
fourTrials(True)
print('without the reset')
fourTrials(False)

It prints:

with the reset
  trial 1 from start 5.8 from origin 5.8
  trial 2 from start 15.3 from origin 15.3
  trial 3 from start 15.3 from origin 15.3
  trial 4 from start 8.6 from origin 8.6
without the reset
  trial 1 from start 5.8 from origin 5.8
  trial 2 from start 15.3 from origin 14.4
  trial 3 from start 15.3 from origin 24.7
  trial 4 from start 8.6 from origin 16.5

The first column is identical in both halves. The second column is where the damage is.

quadrupling the steps, four times over

Three hundred trials at each of four walk lengths, each length four times the last. The third column divides the mean by the square root of the number of steps:

import random


class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def distFrom(self, other):
        xDist = self.x - other.getX()
        yDist = self.y - other.getY()
        return (xDist**2 + yDist**2)**0.5


class Field(object):

    def __init__(self):
        self.drunks = {}

    def addDrunk(self, d, loc):
        self.drunks[d] = loc

    def moveDrunk(self, drunk):
        xDist, yDist = drunk.takeStep()
        self.drunks[drunk] = self.drunks[drunk].move(xDist, yDist)

    def getLoc(self, drunk):
        return self.drunks[drunk]


class UsualDrunk(object):

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        return random.choice(stepChoices)


def walk(f, d, numSteps):
    start = f.getLoc(d)
    for s in range(numSteps):
        f.moveDrunk(d)
    return start.distFrom(f.getLoc(d))


def meanDistance(numSteps, numTrials):
    d = UsualDrunk()
    total = 0
    for t in range(numTrials):
        f = Field()
        f.addDrunk(d, Location(0, 0))
        total = total + walk(f, d, numSteps)
    return total / numTrials


random.seed(11)
print('steps  mean  mean/sqrt(steps)')
for numSteps in [25, 100, 400, 1600]:
    mean = meanDistance(numSteps, 300)
    ratio = mean / numSteps**0.5
    print(numSteps, format(mean, '.2f'), format(ratio, '.2f'))

It prints:

steps  mean  mean/sqrt(steps)
25 4.37 0.87
100 8.85 0.88
400 18.49 0.92
1600 36.91 0.92

The middle column roughly doubles down the table and the third column barely moves. Those are two ways of saying the same thing, and the second one is the one that generalises.

doubling the steps, which does not double the distance

The obvious guess deserves its own measurement. Three hundred trials at 100, 200 and 400 steps:

import random


class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def distFrom(self, other):
        xDist = self.x - other.x
        yDist = self.y - other.y
        return (xDist**2 + yDist**2)**0.5


class UsualDrunk(object):

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        return random.choice(stepChoices)


def meanDistance(numSteps, numTrials):
    d = UsualDrunk()
    total = 0
    for t in range(numTrials):
        start = Location(0, 0)
        here = start
        for s in range(numSteps):
            xDist, yDist = d.takeStep()
            here = here.move(xDist, yDist)
        total = total + start.distFrom(here)
    return total / numTrials


random.seed(19)
means = []
stepCounts = [100, 200, 400]
for numSteps in stepCounts:
    means.append(meanDistance(numSteps, 300))
for i in range(len(means)):
    print(stepCounts[i], format(means[i], '.2f'))
print('doubling once:', format(means[1] / means[0], '.2f'))
print('doubling twice:', format(means[2] / means[0], '.2f'))

It prints:

100 9.16
200 12.52
400 18.35
doubling once: 1.37
doubling twice: 2.00

One doubling gives 1.37 and two doublings give 2.00. A factor that appears once per doubling and squares to two is the square root of two, 1.414.

a walker who leans east, and the rule he breaks

One subclass, one changed line: the step list holds east twice, so east is twice as likely as west. Everything else is the fair walk:

import random


class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y

    def distFrom(self, other):
        xDist = self.x - other.getX()
        yDist = self.y - other.getY()
        return (xDist**2 + yDist**2)**0.5


class Field(object):

    def __init__(self):
        self.drunks = {}

    def addDrunk(self, d, loc):
        self.drunks[d] = loc

    def moveDrunk(self, drunk):
        xDist, yDist = drunk.takeStep()
        self.drunks[drunk] = self.drunks[drunk].move(xDist, yDist)

    def getLoc(self, drunk):
        return self.drunks[drunk]


class UsualDrunk(object):

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        return random.choice(stepChoices)


class EastDrunk(object):
    """Same four steps, but east appears twice, so east is twice as likely"""

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0), (1, 0)]
        return random.choice(stepChoices)


def walk(f, d, numSteps):
    start = f.getLoc(d)
    for s in range(numSteps):
        f.moveDrunk(d)
    return start.distFrom(f.getLoc(d))


def meanDistance(drunkClass, numSteps, numTrials):
    d = drunkClass()
    total = 0
    for t in range(numTrials):
        f = Field()
        f.addDrunk(d, Location(0, 0))
        total = total + walk(f, d, numSteps)
    return total / numTrials


random.seed(13)
drunkClasses = [UsualDrunk, EastDrunk]
for drunkClass in drunkClasses:
    print(drunkClass.__name__)
    for numSteps in [100, 400, 1600]:
        mean = meanDistance(drunkClass, numSteps, 200)
        print(' ', numSteps, format(mean, '.1f'))

It prints:

UsualDrunk
  100 9.0
  400 17.9
  1600 36.4
EastDrunk
  100 20.8
  400 80.9
  1600 319.1

The fair column doubles per quadrupling, as before. The biased column multiplies by about four, which is the signature of a drift rather than of a wander.

the two lists a scatter needs, built and inspected

A scatter takes a list of x values and a list of y values, so the simulation has to hand back both. This is the data half, with no drawing in it:

import random


class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y


class UsualDrunk(object):

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        return random.choice(stepChoices)


def endLocations(numSteps, numTrials):
    """Two lists, the x values and the y values of the final places"""
    d = UsualDrunk()
    xVals = []
    yVals = []
    for t in range(numTrials):
        here = Location(0, 0)
        for s in range(numSteps):
            xDist, yDist = d.takeStep()
            here = here.move(xDist, yDist)
        xVals.append(here.getX())
        yVals.append(here.getY())
    return xVals, yVals


random.seed(0)
xVals, yVals = endLocations(100, 200)
print('walks:', len(xVals))
print('first three x:', xVals[0], xVals[1], xVals[2])
print('first three y:', yVals[0], yVals[1], yVals[2])
print('x from', min(xVals), 'to', max(xVals))
print('y from', min(yVals), 'to', max(yVals))
near = 0
for i in range(len(xVals)):
    if (xVals[i]**2 + yVals[i]**2)**0.5 <= 5:
        near = near + 1
print('ended within 5 of the start:', near)

It prints:

walks: 200
first three x: 6 -4 9
first three y: 2 8 11
x from -21 to 21
y from -19 to 19
ended within 5 of the start: 39

Two hundred walks, ending between 21 west and 21 east, and 39 of them within 5 of the start. Those numbers are what the picture has to agree with.

the drawing calls for the scatter, in order

The same simulation with the pyplot calls attached. The drawing is six lines at the end, and five of the six are labelling:

import random
from matplotlib.pyplot import clf, plot, title, xlabel, ylabel, legend, axis


class Location(object):

    def __init__(self, x, y):
        self.x = x
        self.y = y

    def move(self, deltaX, deltaY):
        return Location(self.x + deltaX, self.y + deltaY)

    def getX(self):
        return self.x

    def getY(self):
        return self.y


class Field(object):

    def __init__(self):
        self.drunks = {}

    def addDrunk(self, d, loc):
        self.drunks[d] = loc

    def moveDrunk(self, drunk):
        xDist, yDist = drunk.takeStep()
        self.drunks[drunk] = self.drunks[drunk].move(xDist, yDist)

    def getLoc(self, drunk):
        return self.drunks[drunk]


class UsualDrunk(object):

    def takeStep(self):
        stepChoices = [(0, 1), (0, -1), (1, 0), (-1, 0)]
        return random.choice(stepChoices)


def endLocations(numSteps, numTrials):
    """Two lists: the x values and the y values of the final places"""
    d = UsualDrunk()
    xVals = []
    yVals = []
    for t in range(numTrials):
        f = Field()
        f.addDrunk(d, Location(0, 0))
        for s in range(numSteps):
            f.moveDrunk(d)
        xVals.append(f.getLoc(d).getX())
        yVals.append(f.getLoc(d).getY())
    return xVals, yVals


random.seed(0)
xVals, yVals = endLocations(100, 200)
clf()
plot(xVals, yVals, 'ro', label='end of walk')
plot([0], [0], 'k*', label='start')
title('Where 200 walks of 100 steps ended')
xlabel('steps east')
ylabel('steps north')
legend(loc='upper left')
axis([-40, 40, -40, 40])

There is nothing printed to show here, which is the point: a plotting program's output is the figure. The left panel of the figure above is this program's picture, drawn from the same seeded run.

one style per class, handed out in a fixed order

With several walker classes in one figure, each needs its own look, and the look has to stay with the class. The lecture files keep a list of format strings and an index; this is the same thing wrapped in a small class:

class StyleIterator(object):
    """Hands out the next plotting style each time it is asked"""

    def __init__(self, styles):
        self.styles = styles
        self.index = 0

    def nextStyle(self):
        style = self.styles[self.index]
        self.index = (self.index + 1) % len(self.styles)
        return style


styles = StyleIterator(['ro-', 'mo--', 'bo:'])
names = ['UsualDrunk', 'EastDrunk', 'ColdDrunk', 'UsualDrunk']
for name in names:
    print(name, styles.nextStyle())

It prints:

UsualDrunk ro-
EastDrunk mo--
ColdDrunk bo:
UsualDrunk ro-

The fourth line is the interesting one: asked a fourth time, the index wraps and the first style comes round again.

the frame that hides the finding

Four yearly means that barely move, and the two frames a program could give them:

means = [11.3, 11.9, 12.4, 12.8]
low = min(means)
high = max(means)
print('lowest', low, 'highest', high)
print('span of the data', format(high - low, '.1f'))
print('span of a frame that starts at zero', format(high - 0, '.1f'))
print('rise as a share of the low value',
      format(100 * (high - low) / low, '.1f'), 'percent')

It prints:

lowest 11.3 highest 12.8
span of the data 1.5
span of a frame that starts at zero 12.8
rise as a share of the low value 13.3 percent

The data spans 1.5. A frame that starts at zero is 12.8 tall, so the whole story occupies about a tenth of the panel and looks flat. A frame from 11.3 to 12.8 fills the panel with that same story and looks like a steep climb.