import random

class Node:
    def __init__(self, r):
        self.routes = r
        self.hopcount = 0

def nexthop(routes):
    return routes[random.randrange(len(routes))]

node1 = Node([2])
node2 = Node([1,3,4,5])
node3 = Node([2,4,5])
node4 = Node([2,3,5])
node5 = Node([2,3,4,6])
node6 = Node([5])

noderoutes = [node1.routes, node2.routes, node3.routes,
    	      node4.routes, node5.routes, node6.routes]

while True:
    for noderoute in noderoutes:
        print(nexthop(noderoute))
    print('end')

maxCount = 10
noderoutes = []
for x in xrange(6):
    node = Node(sorted(random.sample(range(1, maxCount),
                random.randint(1, maxCount-1))))
    noderoutes.append(node)

evilentity fucked around with this message at 19:51 on Feb 14, 2013

JetsGuy fucked around with this message at 21:53 on Feb 14, 2013

x = 2 # the name x points to the object 2
y = (1,2) # y points to the tuple pointing to the objects 1, 2
z = (y,y) # z points to a tuple, both elements pointing to the same object y does

def foo(a): # 
    a = 4 # the name a now points to the object 4
    return a  # return the address of the 4 object.

g = 1
f = foo(g) # f points to the object 4, g still points to the object 1

def foo(a):
    a = [] # we change what address a points to
    a.append(1) # we change the object pointed to by a
    return a 

def bar(a):
    a.append(1) # we change the object pointed to by a
    return a

a = [1,2]
foo(a) # returns [1], a still points to [1,2]

bar(a) # mutates the list pointed to by a, and returns it. 
# a and the return value point to the same list, now containing pointers to 1,2,3

x = 1 # the name x is in the global scope

def a(x): # function argument names are in a function's local scope. 
    x = 2 # changing what x points to here, doesn't change what the outer x points to
    return x

def b(): 
    return x + 1 # x hasn't been bound, so this x is looked up outside the function

def c(): 
    global x # we explicitly say we want the outer x
    x = 2 # this means the x in the outer enviroment
    return x

a(x)
# returns 2, x is still pointing to 1
b()
# returns 2, x is still pointing to 1
c()
# returns 2, x points to the same '2' object.

x = 0
def d():
    x = x + 1 # this errors. by assigning to x, x is a local name, and is unbound.

y = []

def f():
    y.append(1)  # y is global here

def g():
    y+=[2] # this, like y = y + [2], treats y as a local name, and is unboard. like above


f() # the object pointed to by y, now points to the objects  1,2
g() # this is an error - y exists in g's environment, and does not point to an object.

def f():
    x = [] # the name x is local to f
    def g():
        x.append(1) # x is looked up in f's environment
        return x
    x = [0]
    return g

g = f()
g() # returns [0,1]
g() # returns [0,1,1]

h = f() # this creates a new local environment,
h() # returns [0,1] 
h() # returns [0,1,1]

def f():
    x = [] # the name x is local to f
    def g():
        x.append(1) # x is looked up in f's environment, not g's
        return x
    x = [0]
    def h():
        x.append(2) # again, f is looked up in f's environment, not h's
        return x
    return g, h

g,h = f()
g() # returns [0,1]
h() # returns [0,1,2]

def f():
    x = []
    def _g(x): # x is local to _g
        def g():
            x.append(1) # x is looked up in _g's environment, not f's
            return x
        return g

    g = _g(x) # _g creates a local environment, stores the address stored in x

    def _h(x):
        def h():
            x.append(2) # x is looked up in _h's environment, not f
            return x
        return h

    x = [0] # x now points to a new object

    h = _h(x)  # _h creates a new local environment, stores the address stored in x

    return g, h

g,h = f()
g() # returns [1]
h() # returns [0,2]

def f():
    x = [] # the name x is local to f
    def g(x=x): # we copy the address of x into the default argument environment for g
        x.append(1)  # x is local name to g, but points to the object set as the default.
        return x
    x = [0] # we change what x points to
    def h(x=x): 
        x.append(2)  # the x here is local to h, and uses a different object from g
        return x
    return g, h

g,h = f()
g() # returns [1]
h() # returns [0,2]

def f():
    x = [] # the name x is local to f
    def g(x=x): # we copy the address of x into the default argument environment
        x.append(1)  # x is local name to g, but points to the object set as the default.
        return x
    x.append(0) # x still points to the same object, and we change it
    def h(x=x): # again we copy the address of x
        x.append(2) # we only read, so x is looked up in g's environment, not f's
        return x
    return g, h

g,h = f()
g() # returns [0,1]
h() # returns [0,1,2]

def f():
    x = 1
    def g(x=x):
        x = x + 1 # this changes the local x, not the default argument object 
        return x
    return g

g = f()
g() # returns 2
g() # returns 2 # not what we wanted!

def f():
    x = 1
    def g():
        x = x + 1 # x is a local name
        return x
    return g

g = f()
g() # error, x is unbound!

def f():
    x = 1 # the name x is local to f
    def g(): 
        nonlocal x # python 3 magic
        x = x + 1
        return x
    return g

g,h = f()
g() # returns 2
g() # returns 3

tef fucked around with this message at 11:10 on Feb 15, 2013