Python random.r函数代码示例

 def _execute_a_render_mission(self, mission):
     """handle Model mission and do the render"""
     if mission['add_rect']:
         with self.canvas:
             Color(r(), 1, 1, mode='hsv')
             Rectangle(pos=(r() * self.width,
                 r() * self.height), size=(20, 20))

 def getValue(self, fraction, interval, value=None, **kw):
     if value is not None:
         if fraction <= 0.0 or fraction >= 1.0:
             return value
         else:
             from random import random as r
             return [value[0]+r(), value[1]+r(), value[2]+r()]

 def add_rects(self, label, wid, count, *largs):
     label.text = str(int(label.text) + count)
     with wid.canvas:
         for x in xrange(count):
             Color(r(), 1, 1, mode='hsv')
             Rectangle(pos=(r() * wid.width + wid.x,
                            r() * wid.height + wid.y), size=(20, 20))

    def loop(self):
        # Input Suggestion

        from random import randint as r
        import os
        while True:
            os.system('clear')

            # Display status
            # print(80 * '/')
            # print(self.solution)
            # for player in self.hidden_players:
            #     self.player_displayer.display_player(player)

            players = [self.players[i] for i in range(
                len(self.players)) if i != self.suggesting_player_index]
            for player in players:
                self.player_displayer.display_player(player)

            suggestion = {
                CardType.SUSPECT: SUSPECTS[r(0, 5)],
                CardType.WEAPON: WEAPONS[r(0, 5)],
                CardType.ROOM: ROOMS[r(0, 8)],
            }
            print('Turn', self.turn_number)

            turn_start_summary = ' '.join([
                'Player',
                str(self.suggesting_player_index + 1),
                'Suggestion:',
                str(suggestion)
            ])
            print(turn_start_summary)

            acting_players = self.get_acting_players(
                self.players[
                    self.suggesting_player_index
                ]
            )
            for player in acting_players:
                ps = None
                while ps not in ['p', 's', 'x']:
                    print(player.name)
                    ps = input('p/s: ')

                if ps == 's':
                    self.analyzer.player_stopped(player, suggestion)
                    break

                if ps == 'p':
                    self.analyzer.player_passed(player, suggestion)

                if ps == 'x':
                    sys.exit()

            self.turn_number += 1
            self.suggesting_player_index += 1
            if self.suggesting_player_index >= len(self.players):
                self.suggesting_player_index = 0

 def add_planet(self,root,x,y,ray,rho=r()*100000.,mass=r(),*largs):
     wid=physObject()
     wid.mass=1.
     wid.pos=[r()*root.width,r()*root.height]
     wid.rho=1000.
     s=math.sqrt(wid.mass/(wid.rho*math.pi))
     wid.size_hint=(s,s)
     root.add_widget(wid)

def run(parent):
	try:
		play(‘happy_otter.mp3’)
  		move_and_wait(RARM=r(0, 10))	
  		move_and wait(RARM=r(90, 100))
  		move_to(RARM=r(0, 10))
	finally:
		parent.exit()

def draw():
    save("pic.jpeg")
    background(255)
    
    noStroke()
    fill(r(255), r(255), r(255))
    #[draw_square(i,j,r(2)) for i in range(n + 1) for j in range(n + 1)] 
    [draw_sim_square(i,j,r(2)) for i in range((n + 1)/2) for j in range((n + 1)/2)] 
    delay(1000)

def confuse(T):
    print 'confusing data...',
    from random import random as r
    size = len(T)
    for i in range(int(size**1.5)):
        x,y = int(size*r()), int(size*r())
        T[x], T[y] = T[y], T[x]
    print 'finish.'
    return T

def gen_scramble(l):
	scramble = ""
	m=b=9
	for u in range(l):
		c=b;b=m
		while c+b-4 and m==c or m==b:
			m=r(0,5)
		scramble += "URFBLD"[m]+" '2"[r(0,2)]+" "
	return scramble.replace("  "," ")[:-1]

def run(parent):
	try:
		play(‘happy_otter.mp3’)
		move_and_wait(LARM=r(0, 10)); 
		move_and_wait(LARM=r(50, 60))
		move_to(LARM=r(0,10))

	finally:
		parent.exit()

def sendFakeBrainwaves():
    brainwaves = ",".join(
    [str(x) for x in \
        [0] +\
        [r(0,100) for x in range(2)] +\
        [r(0,100000) for x in range(8)]
    ])+"\n"
    print brainwaves
    clientsocket.send(brainwaves)

def run(parent):
	try:
		move_to(PUR=100))
		move_and_wait(NECK=r(0,10))
		move_and_wait(NECK=r(50,60))
		move_and_wait(NECK=r(0,10))
		move_and_wait(NECK=r(50,60))
		move_to(NECK=50)
	finally:
		parent.exit()

 def __init__(self):
   # initialize node-activations
   self.ai = [1.0]*ni
   self.ah = [1.0]*nh
   self.ao = [1.0]*no
   self.Aah, self.Ach, self.Aao, self.Aco = [0]*nh, [0]*nh, [0]*no, [0]*no
   self.wi = [ [r() for j in range(nh)] for i in range(ni) ]
   self.wo = [ [r() for k in range(no)] for j in range(nh) ]
   self.ci = [[0.0]*nh]*ni
   self.co = [[0.0]*no]*nh

def test_ray_passes_through_focus():
    location = [0]*100
    for t in arange(100):
        ray = Ray([r()*5e-2,r()*5e-2,0], [0,0,1], op_wavelength)
        aol.propagate_to_distance_past_aol([ray], 0, focal_length)
        location[t] = ray.position
    
    focus_theory = focus_position + concatenate( (aol_simple.base_ray_positions[3], [aod_spacing.sum()]) ) 
    assert allclose(mean(location, axis=0), focus_theory, rtol=0, atol=1e-3) \
            and all(std(location, axis=0) < 5e-5)

 def add_rects(self, *largs):
     print 'adding_rects', '=' * 80
     wid = self.wid
     count = 1000
     print 'adding', count, 'rects'
     with wid.canvas:
         for x in xrange(count):
             Color(r(), 1, 1, mode='hsv')
             Rectangle(pos=(r() * 100. - 50.,
                            r() * 100. - 50.), size=(100 * r(), 200 * r()))