简单的函数问题。 尝试制作一个简单的掷骰子比赛游戏，跟踪他们掷骰子时的位置

Question

Trying to figure out why the program won't run. This is the error code I am getting: update_position (random_roll_1, random_roll_2) builtins.NameError: name 'random_roll_1' is not defined

I thought I had all the correct parameters but I guess not. Any help would be really appreciated

import random
from random import randint
#both of the players are able to roll out their turs

this is the function where the players can roll their dice and receive a random number

def roll_die(p1_move,p2_move):
     if p1_move is True:
          input('Press enter to roll the die for player 1')
          random_roll_1 = randint(1,6)
          random_roll_1 = str(random_roll_1)
          print('Player 1 rolled ' + random_roll_1)
          random_roll_1 = int(random_roll_1)
          return random_roll_1
     
     elif p2_move is true:
          input('Press enter to roll the die for player 2')
          random_roll_2 = randint(1,6)
          random_roll_2 = str(random_roll_2)
          print('Player 2 rolled ' + random_roll_2)
          random_roll_2 = int(random_roll_2)
          return random_roll_2
          

This part updates the position on where each player is after it rolls the dice. The players have to roll exactly 8 in order to win. Anything higher than that will cause the player to stay in its position

def update_position(random_roll_1, random_roll_2):
     player_1_position = 0
     player_2_position = 0
     max_score = 8
     if player_1_position < max_score:
          if player_1_position + random_roll_1 > 8: 
               print('The roll was too high, player 1 stays in the same spot')
          else:
               player_1_position += random_roll_1
               print('Player 1 moved up ' + random_roll_1 + ' spots!')
          return player_1_position 
     
     elif player_2_position < max_score:
          if player_2_position + random_roll_2 > 8:
               print(' The roll was too high, player 2 stays in the same spot')
          else:
               player_2_position += random_roll_2
               print('Player 2 moved up ' + random_roll_2 + ' spots!')
          return player_2_position
      

this function checks to see if one of the players hit 8 as their score #checks to see if any of the players have managed to reach the end of the game def check_game_over(player_1_position, player_2_position): if player_1_position == 8: print('Player 1 has won!') print('Thank you for playing!') continue_game = False return continue_game

     elif player_2_position == 8:
          print('Player 2 has won!')
          print('Thank you for playing!')
          continue_game = False 
          return continue_game      

This function is what controls who's turn it is. I added in the roll dice function along with the update spot function as it would be easier to include them in one whole function together. This is where I am getting my problem.

#random_roll_1,random_roll_2, player_1_position, player_2_position
#change the turn over to the next player 
def opponent():
     p1_move = True 
     p2_move = False
     if p1_move is True:
          roll_die (p1_move, p2_move)
          update_position (random_roll_1, random_roll_2)
          p1_move = False
          p2_move = True
          return p1_move, p2_move
     
     elif p2_move is True:
          roll_die(p1_move, p2_move)
          update_position (random_roll_1, random_roll_2)
          p1_move = True 
          p2_move = False
          return p1_move, p2_move

This function basically shows the user which location they are currently sitting at.

def display_state (player_1_position, player_2_position, p1_move, p2_move): 
     if p1_move is True:
          player_1_position = str(player_1_position)
          print('Player 1 is in ' + player_1_position + ' spot')
          player_1_position = int(player_1_position)
     
     elif p2_move is True:
          player_2_position = str(player_2_positon)
          print('Player 2  is in ' + player_2_position + ' spot')
          player_2_position = int(player_2_position)
     

Not entirely sure if this function is right at all because I still don't understand main functions completely so not sure if this main function works

def main():
     #display instructions 
     continue_game = True
     while continue_game:
          opponent()
          display_state (player_1_position, player_2_position, p1_move, p2_move)
          check_game_over(player_1_position, player_2_position)

main() 

Answer 1

So there are a few errors in your program above. The runtime error you stated above is caused when you try to pass 2 variables into the update_position function before they have been defined.

roll_die (p1_move, p2_move)
## random_roll_1 and random_roll_2 have not been defined
update_position (random_roll_1, random_roll_2) 

However, before you deal with this error, there is a key programming concept to understand.
Global and Local variables.
A Global variable is one which the entire program can use. They are normally defined at the top of your program:

p1_move = True
p2_move = False

def roll_die(): ...
def main(): ...
etc

A Local variable is one which can only be used inside of the function it was created in.

def foo():
    x = 10
    y = 5
    return x + y

In this example, the variables x and y are local variables and cannot be used in other functions of your program (as they only exist inside the function foo ). One thing to note, in the case where you pass a variable as a functional argument, then modify that variable in the function without returning the modified variable. That variable will only be modified inside that function, no where else. This is true for primitive data types (variables not passed by reference).

def foo(z):
    z += 1

z = 5
foo(z)
print(z)

In this example, the output would be 5, not 6 as the modified z variable in the function foo has not been returned.

For this reason alone, global variables may seem like the better option, however in general global variables are a bad idea and it is recommended that you stick to using local variables.

More information about Global and Local variables .

With this knowledge, some of your errors may seem more obvious. For example, in your function roll_die , you define 2 variables random_roll_1 and random_roll_2 . However you try to use these variables in other functions, update_position for example.
I realise that you have tried to return each random_roll variable independently from the roll_die function, however you do not store these returned values.

# Original
roll_die (p1_move, p2_move)

# Correctly returned
random_roll = roll_die(p1_move, p2_move)

In the next line, you then try to use both random_roll_1 and random_roll_2 variables, even though you only know 1 of those variables at that stage.

# Original
update_position (random_roll_1, random_roll_2)

# Possible Correction
update_position(random_roll)

You would then have to redefine the update_position function, thinking about each player's go as if it happened one after another, and not both at the same time.

I would also like to emphasize the importance of reducing the amount of duplicate code in your program.
Your opponent function could instead be written as:

def opponent(p1_move, p2_move):
    random_roll = roll_die(p1_move, p2_move)
    update_position(random_roll)

    p1_move = not p1_move
    p2_move = not p2_move
    return p1_move, p2_move

This refactoring has changed a few details, most importantly, the use of the not .
This operator will turn True->False and False->True. For example, if p1_move is false, not p1_move is True.

In addition, the function has parameters p1_move, p2_move , as these variables will be required in other parts of your program, you should define them outside of this functions scope , and pass them as arguments into your other functions. And don't forget to store the return values!

Just to note, this function refactoring is an example of how to reduce duplicate code, and is designed to be used with your modified program.

There are a few more modifications required to make your program run, but I will let you work them out for yourself.