在Python中如何设置一个变量大于另一个变量？

我正在尝试用Python制作一个“石头、布、剪刀”游戏，我想将一个变量设置为大于另一个变量

比如：

paper>rock
剪刀>布
石头>剪刀

---

我该怎么做？

您可以通过在对象上定义

\ugt\uu

方法来覆盖

>

操作符的行为。有关更多信息，请参见。

是的，如Daniel所说，通过覆盖

\uuuu cmp\uuuu

，您可以实现以下目标：

class Comparable(object):
    def __init__(self, below_class, above_class):
        self.above_class = above_class
        self.below_class = below_class

    def __cmp__(self, other):
        if isinstance(other, self.below_class):
            return 1
        if isinstance(other, self.above_class):
            return -1
        return 0

class Paper(Comparable):
    pass

class Rock(Comparable):
    pass

class Scissors(Comparable):
    pass

scissors = Scissors(Paper, Rock)
paper = Paper(Rock, Scissors)
rock = Rock(Scissors, Paper)

# True

print paper > rock
print scissors > paper
print rock > scissors

# False

print paper < rock
print scissors < paper
print rock < scissors

可比较类（对象）：
def_uuuuinit_uuuuuuuuuuuuuuuuuu（自我、低于等级、高于等级）：
self.over\u class=高于\u class
self.below_class=below_class
定义cmp（自身、其他）：
如果存在（其他，自身低于\u类）：
返回1
如果存在（其他，自身高于等级）：
返回-1
返回0
课堂论文（可比）：
通过
岩石类别（可比）：
通过
类别剪刀（可比）：
通过
剪刀=剪刀（布、石头）
纸=纸（石头、剪刀）
石头=石头（剪刀、布）
#真的
打印纸>摇滚乐
印刷剪刀>布
印刷石头>剪刀
#假的
打印纸<岩石
印刷剪刀<纸
印石剪刀

---

这里有关于这一工作方式的文档：

这实际上是一个有趣的问题，因为它提出了一些有用的想法

举个例子，如果纸剪刀和石头剪刀遵循定律，这将是一个微不足道的问题。假设

布>石头>剪刀

在数学上是正确的（即

布>剪刀

，与游戏规则相反）：

类首（对象）：
定义初始（自我，武器）：
武器_值={‘纸’：2，‘石头’：1，‘剪刀’：0}
自我武器价值=武器价值[武器]
定义（自身、其他）：
返回self.wealth\u value>other.wealth\u value
定义（自身、其他）：
返回self.wealth\u值

现在我们可以检查：

In [7]: paper > rock
Out[7]: True

In [8]: rock == rock
Out[8]: True

In [9]: paper < scissors
Out[9]: False

In [10]: scissors < rock
Out[10]: True

[7]中的

：纸张>岩石
Out[7]：对
在[8]中：rock==rock
Out[8]：对
在[9]中：布<剪刀
Out[9]：假
在[10]中：剪刀<石头
Out[10]：对

不幸的是，布石头剪刀有一个循环逻辑，因此通常的不等式概念在这种情况下不起作用（因此，

paper

的计算结果为

False

）

---

您可以使用自定义的可比项，但请记住，这会产生一些矛盾，例如

rock>剪刀>paper==True

，当然

rock

在您的案例中，我建议创建一个返回赢家的函数。差不多

def winner(J1, J2):
    if J1 == 'rock':
        if J2 == 'paper':
            return('J2')
        if J2 == 'rock':
            return('draw')
        if J2 == 'paper':
            return('J1')
    ...

---

这将允许您查看谁获胜。

对于不涉及重新定义运算符的简单解决方案：

首先定义游戏规则：

class fist(object):

   def __init__(self, weapon):
       WEAPON_VALUES = {'paper': 2, 'rock': 1, 'scissors': 0}
       self.weapon_value = WEAPON_VALUES[weapon]

   def __gt__(self, other):
       return self.weapon_value > other.weapon_value

   def __lt__(self, other):
       return self.weapon_value < other.weapon_value

   def __eq__(self, other):
       return self.weapon_value == other.weapon_value

   def __ne__(self, other):
       return self.weapon_value != other.weapon_value    

paper = fist('paper')

rock = fist('rock')

scissors = fist('scissors')

rules = ['paper>rock', 'rock>scissors', 'scissors>paper']

并使用如下函数根据规则检查数据：

def greater(opt1, opt2):
    if opt1 == opt2:
        return None # draw
    return "{0}>{1}".format(opt1, opt2) in rules

>>> greater('paper','rock')
True
>>> greater('paper','scissors')
False
>>> greater('rock','paper')
False

---

你试过什么吗？如果您还向我们展示您尝试过的代码，这对我们总是很好的。请注意，这种事情通常不是一个好主意，因为您无法创建具有这些关系的对象。基本上，如果你像你描述的那样定义

，它会破坏其他内置机制，比如

sort（）

，因为排序是循环的。给我们看看你的代码。我不知道这是为什么，它不能解决您自己的测试用例给出的问题：

paper

@MarkRansom Yes我在回答中解释过，这是一个例子，其中paper>rock>scissors在数学上是正确的（即paper>scissors）。然后解释了为什么这种方法不会被推荐用于纸石剪刀的实际规则（不平等悖论）。但可能还不够清楚-你有没有建议我如何更清楚地传达这一点？任何有效的解决方案都存在悖论，我认为这是你答案中最好的部分。我的问题是，它在一些不应该是悖论的测试中失败了。也就是说，你没有回答实际问题。当然，我想解释一下为什么没有解决方案是一个明智的想法，因为你打破了人们正确理解的不平等概念。我现在已经链接到正确的解决方案，因此希望这可以作为对已接受答案的有用补充。不过，我确实理解你的担忧。（我对实际问题的含蓄回答是：“不要这样做”。）你能解释一下这个

类纸（可比的）：通过类岩石（可比的）：通过类剪刀（可比的）：pass

@ikuro这些只是生成了3个子类的

Comparable

，它们与

Comparable

没有什么区别，只是类型不同。因为它们有不同的类型，您可以像在

\uu\cmp\uu

中那样比较这些类型。