python函数随机循环if语句

我在做一个石头剪纸游戏，遇到了

decisioncycle（）

的问题。我试图做的是让用户在

usercycle（）

中输入一个选项，让计算机在

gamecycle（）

中生成一个随机选项，然后确定谁赢了这一轮，并用赢和输计数跟踪每个结果。它似乎在决定什么时候随机工作

import random


class rpsgame:

    rps= ["rock", "paper","scissors"]


    wincount=0
    losecount=0
    def usercycle(self):
        userchoice = input("rock, paper, scissor.....")
        print("SHOOT")
        return userchoice

    def gamecycle(self):
        computerchoice = random.choice(rpsgame.rps)
        return computerchoice




    def decisioncycle(self):
            if rpsgame.usercycle(self) == rpsgame.rps[0] and rpsgame.gamecycle(self) == rpsgame.rps[1]:
                    print("paper beats rock, you lose!")
                    rpsgame.losecount +=1
            elif rpsgame.usercycle(self) == rpsgame.rps[1] and rpsgame.gamecycle(self) == rpsgame.rps[0]:
                    print("paper beats rock, you win!")
                    rpsgame.wincount+=1
            elif rpsgame.usercycle(self) == rpsgame.rps[0] and rpsgame.gamecycle(self) == rpsgame.rps[2]:
                    print("rock beats scissors, you win!")
                    rpsgame.wincount+=1
            elif rpsgame.usercycle(self) == rpsgame.rps[2] and rpsgame.gamecycle(self) == rpsgame.rps[0]:
                    print("rock beats scissors, you lose!")
                    rpsgame.losecount+=1
            elif rpsgame.usercycle(self) == rpsgame.rps[1] and rpsgame.gamecycle(self) == rpsgame.rps[2]:
                    print("scissors beats paper, you lose!")
                    rpsgame.losecount+=1
            elif rpsgame.usercycle(self) == rpsgame.rps[2] and rpsgame.gamecycle(self) == rpsgame.rps[1]:
                    print("scissors beats paper, you win!")
                    rpsgame.wincount+=1
            elif rpsgame.usercycle(self) == rpsgame.gamecycle(self):
                    print("it's a tie!!!")
            print("wins {}, losses {}".format(rpsgame.wincount, rpsgame.losecount))




while True:
    rg = rpsgame()
    rg.usercycle()
    rg.gamecycle()
    rg.decisioncycle()

---

我认为我的问题在于决策周期（）。这是我第一次尝试一个类，因为游戏使用的是全局变量，但我在这里读到，这是一个不好的实践，在未来进行。

您要求在每个条件下都有一个新的用户输入。你可能只想读一次，然后每次都比较一下

user_choice = self.usercicle()
game_choice = self.gamecycle()
if(user_choice == self.rps[0] and game_choice == self.rps[1]):
    print "Paper beats rock, you lose!"
    self.losecount += 1
elif( user_choice...

---

等等

这里有很多古怪的东西，但我认为你遇到的问题是，你把

self

传递给一个函数，而这个函数（实际上）不接受参数作为输入

class TestClass(object):
    def some_method(self):
        return random.choice(['rock', 'paper', 'scissors'])
    def make_choice(self):
        return self.some_method(self)
        # raises TypeError

一个方法的类会被自动指定它所属的实例作为第一个参数。如果您再次尝试通过，它将失败

也就是说，我认为你们的班级应该是这样的：

class Roshambo(object):
    ROCK = 'rock'
    PAPER = 'paper'
    SCISSORS = 'scissors'

    OPTIONS = [ROCK, PAPER, SCISSORS]

    def get_user_input(self):
        choice = input("r/p/s? ").lower()
        if choice.startswith('r'): choice = self.ROCK
        elif choice.startswith('p'): choice = self.PAPER
        elif choice.startswith('s'): choice = self.SCISSORS
        else:
            # what do we do now?
            pass  # for now
        return choice

    def get_computer_input(self):
        return random.choice(self.OPTIONS)

    def start(self):
        # get input ONCE...
        user_choice = get_user_input()
        computer_choice = get_computer_input()

        if user_choice == ROCK and computer_choice == ROCK:
            # tie
        # etc....

然后实例化

game = Roshambo()

跑

game.start()

---

您可以使用模运算，而不是使用许多循环来计算每个组合

假设您进行了映射

"rock" => 0
"paper"=>1
"scissors" => 2

您可以将解决方案评估为

(A.number - B.number) % 3

---

如果结果为0，则为平局；如果结果为1，则如果2 A丢失，则为赢

我认为您应该使用单独的函数来确定赢家，并使用dict，而不是7路if语句：

def who_won(player, computer):
    rules = {"rock": "scissors", "paper": "rock", "scissors": "paper"}
    if player == computer:
        return None
    if rules[computer] == player:
        return "computer"
    return "player"

---

检查无效输入可能是个好主意，但这应该在输入函数中完成，而不是在该函数中完成。

我认为这实际上可以简化。有一些错误，它们看起来像是由于对类的简单不熟悉造成的。请看这里：

class RpsGame:

    # create a game loop. Let's try a while loop
    # also, let's try using a dict to make comparisons easier

    def play(self):
        rps = {'rock':'scissors', 'paper':'rock', 'scissors':'paper'}
        score = 0
        # lets just say player must win 3 or lose 3 to end the game
        while -3 < score < 3:
            # ask user for their choice just once here, for instance
            user = raw_input("Rock, paper or scissors: ").lower()
            # and check the input is valid
            # get the computer choice with random

            # then find the winner and adjust score
            # when score reaches -3, computer wins etc.
            # comparisons could go like:
            if com == rps[user]: 
                score += 1
            elif user == rps[com]:
                score -= 1

        self.game_over(score)

    def game_over(self, score):
        if score == -3:
            result == "You win"
        else:
            result == "You lose"

        print "%s!!" % result


# We would start by instantiating the game
game = RpsGame()
# And then calling the play method
game.play()

class RpsGame:
#创建一个游戏循环。让我们试一下while循环
#另外，让我们尝试使用dict来简化比较
def播放（自我）：
rps={'rock'：'Scissor'，'paper'：'rock'，'scissors'：'paper'}
分数=0
#让我们只说玩家必须赢3或输3才能结束游戏
而-3<得分<3：
#例如，在这里只向用户询问一次他们的选择
用户=原始输入（“石头、布或剪刀”）。下（）
#并检查输入是否有效
#随机选择计算机
#然后找到获胜者并调整分数
#当分数达到-3时，计算机获胜，以此类推。
#比较可能是这样的：
如果com==rps[用户]：
分数+=1
elif user==rps[com]：
分数-=1
赛尔夫。比赛结束（得分）
def游戏结束（自我，得分）：
如果得分==-3：
结果==“你赢了”
其他：
结果==“你输了”
打印“%s！！%”结果
#我们将从实例化游戏开始
game=RpsGame（）
#然后调用play方法
游戏

---

如果我也是你的话，我会去读更多关于类和“self”用法的书。

在decisioncycle中，每个if/elif语句都像是游戏中的一轮，我认为这不是你真正想要的。确切地说，当我这样写出来时，没有使用全局变量的类，它就按预期工作了。我到底遗漏了什么？在决定游戏结果的任何函数中，您都应该只调用usercycle和gamecycle一次，并将结果分配给两个变量。然后用这些变量进行比较。事实上，这是可行的，但我仍然不完全理解为什么它首先适用于全局变量，这本身就是一个教训。我可能应该远离globals…不，因为computerchoice和userchoice是gamecycle和usercycle函数的本地功能。它们不存在于这些功能之外。如果你想让它们成为rpsgame的属性，你必须在它们前面加上self，例如，

self.computerchoice

。他在

decisioncycle

中用

self

调用的所有调用都是完全有效的-他不是在实例上调用它们，而是直接在类上调用它们。诚然，他根本不应该在那里调用它，但他这样称呼肯定不是他的问题@Ben嗯，我确实错过了他实际上是在调用

self.\uuu class\uuuuu.methodname（self）

，但即使这没有导致错误，也绝对没有帮助！！可能是枚举的一个很好的用途，尽管目前还不清楚该算法是如何工作的。在我在这里看到的所有RPS游戏中，我从未见过提供的算术方法！我的意思是，如果它在所有情况下都有效的话，那真的很酷。它是可扩展的吗？（例如，石头剪刀蜥蜴斯波克）如果你认为A-B是差分，你可以把它看作是-1,0或1的差分，或者在有限域中0,1和2（2与-1相同）。它来自数论，被称为有限域算术。例如，在C语言中，%不是这样工作的，我们应该把它写成（3+A-B）%3看看这个区别，我注意到你在第三个函数中运行前面的两个函数，然后调用第三个函数来运行整个脚本。这是一种更干净的方法，但我尝试了这一点，它给了我同样的结果。我更多的是建议另一种方法来实现

decisioncycle

的主体。如果没有其他选择，您可以在顶部打印这两个选项，并尝试找出哪对答案有效或无效。请注意，

self

不是关键字！：）