title: Another Simple Random Walk Simulation Using Python(Two-Dimensional)
body: <p>I'm trying to solve a two-dimensional random walk problem from the book, exploring python.
  But, I couldn't figure out how can I solve this problem.I made some research but those were too complicated to understand what is it about. I'm a beginner learner. So, I can't understand the code by looking it. Please explain me this problem in details.</p>
  
  <p>Anyway, the question is:</p>
  
  <blockquote>
    <p>The two dimensional variation on the random walk starts in the middle
    of a grid, such as an 11 by 11 array. At each step the drunk has four
    choices: up, down, left or right. Earlier in the chapter we described
    how to create a two-dimensional array of numbers. Using this data
    type, write a simulation of the two-dimensional random walk.</p>
  </blockquote>
  
  <p>Ok, What I know;
  I know how to create two dimensional array in python:</p>
  
  <pre><code>times = [0] * 11
  for i in range(0,11):
      times[i] = [0] * 11
  </code></pre>
  
  <p>And I got the idea of "randint" function:</p>
  
  <p>And also I have written the one dimensional variation of this problem recently. But it is a spaghetti code code and and it is very dirty and also I'm not sure if it is right.</p>
  
  <p>My code is here:</p>
  
  <pre><code>'''
  Created on Feb 11, 2012
  
  @author: msarialp
  '''
  from random import randint
  
  def drunken_man():
      steps = 0
      times = [0] * 11
      left_move = 0
      right_move = 0
      i = 0
      while left_move &lt; 5 or right_move &lt; 5:
          value = randint(0,1)
          times[5] = 1
          if value == 1:
              steps += 1
              print("He moved left")
              left_move += 1
              if right_move &gt; 0:
                  right_move -= 1
              if left_move == 1:
                  times[4] += 1
              elif left_move == 2:
                  times[3] += 1
              elif left_move == 3:
                  times[2] += 1
              elif left_move == 4:
                  times[1] += 1
              #elif left_move == 5:
                  #times[0] += 1
          elif value == 0:
              steps += 1
              print("He moved right")
              right_move += 1
              if left_move &gt; 0:
                  left_move -= 1
              if right_move == 1:
                  times[6] += 1
              elif right_move == 2:
                  times[7] += 1
              elif right_move == 3:
                  times[8] += 1
              elif right_move == 4:
                  times[9] += 1
              #elif right_move == 5:
                  #times[10] += 1
          times[i] += 1                
      for i in range(1,10):
          print("He took {steps} steps until he reaches end of the sidewalk.".format(steps = steps),  "He stood on {1} square at {0} times".format(times[i], i) )
  
  def main():
      drunken_man()
  
      return 0
  if __name__ == '__main__':
      main()
  </code></pre>
  
  <p><strong>EDIT One</strong></p>
  
  <p>After taking some good advices from Dan Gerhardsson.
  I've decided to edit my question.
  So where I am on this question:
  I understand how can I follow and examine the steps of my drunken man at two-dimesion.</p>
  
  <p>It was very understandable and clear to use tuple to solve this exercise.</p>
  
  <p>So, after all my code segment is here, Please check and give me any feedbacks.</p>
  
  <pre><code>def two_dimensional_random_walk():
      steps = 0
      times = [0] * 11
      for i in range(0,11):
          times[i] = [0] * 11
      x = 5
      y = 5
      moves = [(1,0), (0,1), (-1,0), (0,-1)]  
      while x&lt;11 and x &gt;= 0 or y &lt; 11 and y &gt;= 0:  
          dx, dy = moves[randint(0,3)]
          x += dx
          y += dy
          if dx == 1 and dy == 0:
              print("He moved right")
          elif dx == 0 and dy == 1:
              print("He moved up")
          elif dx == -1 and dy == 0:
              print("He moved left")
          elif dx == 0 and dy == -1:
              print("He moved down")
          try:
              times[x][y] += 1
              steps += 1
          except IndexError:
              break
  </code></pre>
  
  <p>And my print function is:</p>
  
  <pre><code>for i in range(0,11):
      for j in range(0,11):
          print("He took {steps} steps until he reaches end of the sidewalk.".format(steps = steps),  "He stood on {1}x{2} square at {0} times".format(times[i][j], i+1,j+1) )   
  </code></pre>
  
  <p>So all in all I guess with helps by Dan Gerhardsson, I solved the exercise.</p>
  
  <p>But, Why won't I change my one dimensional solution with those hints.</p>
  
  <pre><code>def drunken_man():
  steps = 0
  x = 6
  times = [0] * 11
  moves = [(1), (-1)]
  
  while x &lt; 11 and x &gt;= 0:
      dx = moves[randint(0,1)]
      print(dx, x)
      x += dx
      try:
          times[x] += 1
          steps += 1
      except IndexError:
          break           
  for i in range(1,11):
      print("He took {0} steps until he reaches end of the sidewalk.".format(steps),  "He stood on {1} square at {0} times".format(times[i], i) )
  </code></pre>
  
  <p><strong>EDIT Two(Final touches)</strong></p>
  
  <p>I'm not sure whether it is necessary to edit my post for applying the hints by Dan Gerhardsson. In order to help someone who misses the points like me, I decided to combine everything together.</p>
  
  <p>So here is my function that is combined with hints by Dan Gerhardsson:</p>
  
  <pre><code>def two_dimensional_random_walk():
  steps = 0 # Steps counter for understand how many steps that our drunken man take
  grid_size = 11 # Grid size variable,
  # Creating Two dimensional array by using lists
  times = [0] * grid_size 
  for i in range(0,grid_size):
      times[i] = [0] * grid_size
  # Initial variables to start in the middle of grid
  x = 5
  y = 5
  # Tuples to get directions and decide where to go
  moves = [(1,0, "right"), (0,1, "up"), (-1,0, "left"), (0,-1, "down")] 
  # My loop for evaluate the steps
  while True:  
      dx, dy, position = moves[randint(0,3)] # By using randint I could make decision randomly
      x += dx
      y += dy
      print("He moved", position)
      try:
          times[x][y] += 1 # And here is, how many times have he stood on each square
          steps += 1
      except IndexError: # The exit of loop
          break
  # My print function which answers these questions (How long will it be until he reaeches the end of the sidewalk, and how many times will he have stood on each square)
  for i in range(0,11):
      for j in range(0,11):
          print("He took {steps} steps until he reaches end of the sidewalk.".format(steps = steps),  "He stood on {1}x{2} square at {0} times".format(times[i][j], i+1,j+1) )
  </code></pre>
  
  <p>Thanks for your big helps Dan Gerhardsson.
  I guess finally I've got the solution.</p>