从不同的父类调用方法(具有相同的名称)，但结果显示代码只运行其中一个

我制作了三种骰子，然后用杯子包裹它。Cup 继承两个类(继承相同的基类(。在 cup，我从两个父类和基类调用了三个 roll 方法。

当我运行cup.roll时，我应该得到三个数字，第一个应该在1-6之间，第二个应该在1-10之间，第三个应该在1-20之间。但是我跑了很多次，结果显示所有三个数字的范围都在 1-10 之间，这意味着只有 roll 方法仅派生自父类之一。

为什么会这样？以及如何解决这个问题？我刚刚从Python开始。

更新

上面的问题可以通过更改 Cup 的结构来解决，但我遇到了一个新问题。

现在，代码工作正常，直到我输出结果的最后一部分，应该有三个列表从三个骰子返回，但最后两个是空的，当滚动和求和时，它们不是空的。很奇怪。

输出：

# >>> c = cup(2,3,4)
# 2 3 4
# >>> c.roll()
# (when print out roll in dices)
# [5, 2]
# [2, 6, 2]
# [6, 6, 2, 5]
# (but, when print out roll in cup, two become empty)
# [5, 2] [] []
# 36

法典：

class SixSidedDie:
sides = 6
valueLst = []
sumVal = int()
def __init__(self, nOfDie):
self.nOfDie = nOfDie
def roll(self):
import random
self.valueLst = []
for i in range(1, self.nOfDie+1):
self.valueLst.append(random.randint(1,self.sides))
print(self.valueLst)
return self.valueLst
def sum(self):
self.sumVal = 0
for i in self.valueLst:
self.sumVal += i
return self.sumVal
def getFaceValue(self):
return self.valueLst
def __repr__(self):
return 'SixSidedDie({})'.format(self.faceValue)

class TenSidedDie(SixSidedDie):
sides = 10          
def __repr__(self):
return 'TenSidedDie({})'.format(self.faceValue) 

class TwentySidedDie(SixSidedDie):
sides = 20
def __repr__(self):
return 'TwentySidedDie({})'.format(self.faceValue) 


class cup():   
sixSDLst = []
tenSDLst = []
twentySDLst = []
def __init__(self, nOfSixSdDie = 1, nOfTenSdDie = 1, nOfTwentySdDie = 1):
self.sixSdDie = SixSidedDie(nOfSixSdDie)
self.tenSdDie = TenSidedDie(nOfTenSdDie)
self.twentySdDie = TwentySidedDie(nOfTwentySdDie)
print(nOfSixSdDie, nOfTenSdDie, nOfTwentySdDie)
def roll(self):
self.sixSDLst = self.sixSdDie.roll()
self.tenSDlst = self.tenSdDie.roll()
self.twentySDlst= self.twentySdDie.roll()
print(self.sixSDLst,self.tenSDLst,self.twentySDLst)
return self.sixSdDie.sum() + self.tenSdDie.sum() + self.twentySdDie.sum()
def getSum(self):
return self.sixSdDie.sum()+ self.tenSdDie.sum() + self.twentySdDie.sum()
def __repr__(self):
output = ''
for i in self.sixSDLst:
output = output + 'SixSidedDie(' + str(i) +'),'
for j in self.tenSDLst:
output = output + 'TenSidedDie(' + str(i) +'),'
for k in self.twentySDLst[:-1]:
output = output + 'TwentySidedDie(' + str(i) +'),'
output = 'Cup(' + output + 'TwentySidedDie(' + str(self.twentySDLst[-1]) +')' + ')'
return output

首先，正如其他人所说，你使用继承是错误的，但我把它归结为家庭作业的要求。

在您的骰子子类中，尝试更新__init__方法中的边数：

class TenSidedDie(SixSidedDie):
def __init__(self):
self.sides = 10
def __repr__(self):
return 'TenSidedDie({})'.format(self.faceValue)

此外，在点名时，您不需要包含 self。

for k in range(1, self.nOfTwentySdDie+1):
self.fVOfTwentySdDie.append(TwentySidedDie.roll())

使用更新后的代码：

注释掉全局初始化列表对我有用。

作为旁注，在打印信息时，您希望能够查看日志并立即理解它。我建议在掷骰子方法中添加以下行：print('Rolling [{}], count: [{}] values: {}'.format(self.sides, self.nOfDie, self.valueLst))这将告诉您掷骰子的大小、数量以及每个骰子的结果。不再解析日志。

由于您只有技术问题，而不是要求您为您完成家庭作业，因此这就是我拥有的适合我的代码。我做了一些小的重写，使其更易于管理，并添加了日志记录：

import random
class SixSidedDie:
sides = 6
valueLst = []
sumVal = int()
def __init__(self, nOfDie):
print('intializing d6 with [{}] dice'.format(nOfDie))
self.nOfDie = nOfDie
def roll(self):
self.valueLst = []
for i in range(1, self.nOfDie+1):
self.valueLst.append(random.randint(1,self.sides))
print('Rolling {} d{} values: {}'.format(self.nOfDie, self.sides, self.valueLst))
return self.valueLst
def sum(self):
self.sumVal = 0
for i in self.valueLst:
self.sumVal += i
return self.sumVal
def getFaceValue(self):
return self.valueLst
def __repr__(self):
return 'SixSidedDie({})'.format(self.faceValue)
class TenSidedDie(SixSidedDie):
def __init__(self, nOfDie):
print('intializing d10 with [{}] dice'.format(nOfDie))
self.nOfDie = nOfDie
self.sides = 10
def __repr__(self):
return 'TenSidedDie({})'.format(self.faceValue) 
class TwentySidedDie(SixSidedDie):
def __init__(self, nOfDie):
print('intializing d20 with [{}] dice'.format(nOfDie))
self.nOfDie = nOfDie
self.sides = 20
def __repr__(self):
return 'TwentySidedDie({})'.format(self.faceValue) 

class cup():
def __init__(self, nOfSixSdDie = 1, nOfTenSdDie = 1, nOfTwentySdDie = 1):
self.sixSdDie = SixSidedDie(nOfSixSdDie)
self.tenSdDie = TenSidedDie(nOfTenSdDie)
self.twentySdDie = TwentySidedDie(nOfTwentySdDie)
def getSum(self):
return self.sixSdDie.sum()+ self.tenSdDie.sum() + self.twentySdDie.sum()
def roll(self):
self.sixSdLst = self.sixSdDie.roll()
self.tenSdLst = self.tenSdDie.roll()
self.twentySdLst = self.twentySdDie.roll()
return self.getSum()
def __repr__(self):
output = ''
print('6 sided : [{}]n10 sided: [{}]n20 sided: [{}]'.format(len(self.sixSdLst), len(self.tenSdLst), len(self.twentySdLst)))
for i in self.sixSdLst:
output += 'SixSidedDie(' + str(i) +'),'
output += 'n'
for j in self.tenSdLst:
output += 'TenSidedDie(' + str(j) +'),'
output += 'n'
for k in self.twentySdLst:
output += 'TwentySidedDie(' + str(k) +'),'
result = 'Cup(' + output + ')'
return result

play_cup = cup(20, 20, 20)
print('ROLL:', play_cup.roll())
print('SUM:', play_cup.getSum())
print(play_cup)

结果：

intializing d6 with [5] dice
intializing d10 with [5] dice
intializing d20 with [5] dice
Rolling 5 d6 values: [1, 2, 2, 2, 3]
Rolling 5 d10 values: [6, 4, 5, 7, 3]
Rolling 5 d20 values: [9, 8, 2, 5, 10]
ROLL: 69
6 sided : [5]
10 sided: [5]
20 sided: [5]
[1, 2, 2, 2, 3]
[6, 4, 5, 7, 3]
[9, 8, 2, 5, 10]
Cup(SixSidedDie(1),SixSidedDie(2),SixSidedDie(2),SixSidedDie(2),SixSidedDie(3),
TenSidedDie(6),TenSidedDie(4),TenSidedDie(5),TenSidedDie(7),TenSidedDie(3),
TwentySidedDie(9),TwentySidedDie(8),TwentySidedDie(2),TwentySidedDie(5),TwentySidedDie(10),)

之所以发生，是因为边是从TenSidedDie继承的，然后你把它作为自己传递给每个卷子。在cup定义的开头添加print(self.sides)以查看其运行情况。来自 python 类文档：

class DerivedClassName(Base1, Base2, Base3):
<statement-1>
.
.
.
<statement-N>

在大多数情况下，在最简单的情况下，您可以考虑搜索对于从父类继承为深度优先的属性，从左到右，不在同一类中搜索两次，其中有一个层次结构中的重叠。因此，如果在 DerivedClassName，它在 Base1 中搜索，然后(递归地(在 Base1 的基类，如果在那里找不到，它是在 Base2 中搜索，依此类推。

删除继承后，您可以执行以下操作来解决：

six_die =  SixSidedDie()
for i in range(1, self.nOfSixSdDie+1):            
self.fVOfSixSdDie.append(six_die.roll())

更新

相关内容

最新更新

热门标签：