列表中相同位置对象的计算和比较

Question

我有一个问题，希望你能帮助我。在我的项目中，我有一个虚拟时间，它会在脚本启动后立即运行（1 秒中的 24 虚拟秒）。这个时间记录在一个列表中，并从 main 传递给需要它的 classes。该列表由五个元素组成[0, 0, 0, 0, 0]，第一个是分钟，第二个是小时，第三个是天，第四个是月，第五个是年

self.gTime = self.__engine.time
self.vTime = copy.deepcopy(self.gTime)

gTime是一般虚拟时间，vTime是根据事件变化的时间。

__grow = {
        "0": [10, 0, 0, 0, 0],
        "1": [10, 0, 0, 0, 0],
        "2": [10, 0, 0, 0, 0],
        "3": [10, 0, 0, 0, 0],
        "4": [10, 0, 0, 0, 0],
    }

这是一本迷你词典，其中有五个必须发生的事件。这些事件（里面的数字目前用于测试）用简单的话表示该事件发生需要经过多长时间。每当该事件发生时，vTime 将更新为 gTime 的值，并且循环继续下一阶段。

所以我创建了这个函数：

def update_age(self):
    if self.__age <= len(self.__grow) - 1:
        for i, n in enumerate(self.gTime):
            if abs(self.gTime[i] - self.vTime[i]) == self.__grow[str(self.__age)][i]:
                self.vTime = copy.deepcopy(self.gTime)
                self.__age += 1
    else:
        pass

其中 age 决定应该发生哪个事件。

现在，如果我启动脚本，我会收到此错误：

if abs(self.gTime[i] - self.vTime[i]) == self.__grow[str(self.__age)][i]:
KeyError: '5'

此外，在脚本错误结束之前，我可以看出事件的顺序发生得太快了。

如果我将 self.__grow[str (self.__age)][i] 替换为例如 10，则脚本可以正常工作。

我应该如何更改才能使其正常工作？感谢您的帮助。

编辑：

在主class中滚动时间是这样生成的：

self.__time = [0, 0, 0, 0, 0, 0, 0]
self.time = [0, 0, 0, 0, 0]

def __time_update(self):
    time = datetime.now()
    if int(time.strftime("%S")) != self.__time[0]:
        self.__time[0] = copy.deepcopy(int(time.strftime("%S")))
        if self.__time[1] >= 60:
            self.__time[1] = self.__time[1] - 60
            self.__time[2] += 1
        if self.__time[2] >= 60:
            self.__time[2] = 0
            self.__time[3] += 1
        if self.__time[3] >= 24:
            self.__time[3] = 0
            self.__time[4] += 1
        if self.__time[4] >= 30:
            self.__time[4] = 0
            self.__time[5] += 1
        if self.__time[5] >= 4:
            self.__time[5] = 0
            self.__time[6] += 1

        self.__time[1] += 24

        if self.__time[2] % 10 == 0:
            self.time[0] = copy.deepcopy(self.__time[2])
        self.time[1] = copy.deepcopy(self.__time[3])
        self.time[2] = copy.deepcopy(self.__time[4])
        self.time[3] = copy.deepcopy(self.__time[5])
        self.time[4] = copy.deepcopy(self.__time[6])

__time 每次退出脚本时，它都会在外部保存并在再次启动脚本时重新加载。

例如，第一部分应该模拟一棵树的生长（由五个阶段组成），该部分必须在实体生成后立即开始。每当 age 发生变化（因此发生了一个阶段）时，精灵就会更改为新的。

编辑 2：

不幸的是，建议的解决方案在解决生成的错误时来自不同类型的问题：Click for image 在第一部分，它是您如何看待它执行建议的更改。理论上的第二部分是我通过将 self.__grow[str (self.__age)][i] 替换为例如 10 得到的应该如何（在测试中，到最后阶段的更改应该每 10 分钟发生一次）。最后一部分是错误。

要么我改一下虚拟时钟的工作方式，要么我真心不知道怎么解决...

编辑 3：

最后，我设法通过创建一个外部模块来解决：

from datetime import datetime
from copy import deepcopy

gTime = [0, 0, 0, 0, 0]
name_day = 0

__dt = 0
__s = 0
__m = 0
__h = 0
__dy = 0
__st = 0
__mh = 0
__y = 0

__local = "it"

__nDay = {
    "en": {
        "0": "Monday",
        "1": "Tuesday",
        "2": "Wednesday",
        "3": "Thursday",
        "4": "Friday",
        "5": "Saturday",
        "6": "Sunday"
    },
    "it": {
        "0": "Lunedì",
        "1": "Martedì",
        "2": "Mercoledì",
        "3": "Giovedì",
        "4": "Venerdì",
        "5": "Sabato",
        "6": "Domenica"
    },
}


def time_update():
    global __dt, __s, __m, __h, __dy, __st, __mh, __y, gTime, name_day

    vTime = datetime.now()
    if int(vTime.strftime("%S")) != __dt:
        __dt = deepcopy(int(vTime.strftime("%S")))
        if __s >= 60:
            __s = __s - 60
            __m += 1
        if __m >= 60:
            __m = 0
            __h += 1
        if __h >= 24:
            __h = 0
            __dy += 1
            __st += 1
        if __st >= 7:
            __st = 0
        if __dy >= 30:
            __dy = 0
            __mh += 1
        if __mh >= 4:
            __mh = 0
            __y += 1

        __s += 24

        if __m % 10 == 0:
            gTime[0] = deepcopy(__m)
        gTime[1] = deepcopy(__h)
        gTime[2] = deepcopy(__dy)
        gTime[3] = deepcopy(__mh)
        gTime[4] = deepcopy(__y)

        name_day = __nDay[__local][str(__st)]

def calculation_time(vList, cList):
    m = vList[0] + cList[0]
    h = vList[1] + cList[1]
    d = vList[2] + cList[2]
    ms = vList[3] + cList[3]
    y = vList[4] + cList[4]

    if m >= 60:
        h += 1
        m = 0
    if h >= 24:
        d += 1
        h = 0
    if d >= 30:
        ms += 1
        d = 0
    if ms >= 4:
        y += 1
        ms = 0

    if gTime[0] >= m:
        if gTime[1] >= h:
            if gTime[2] >= d:
                if gTime[3] >= ms:
                    if gTime[4] >= y:
                        return True

time_update() 每次更新时由主 class 调用，而 calculation_time() 由需要知道的个体实体 classes 调用是时候改变行为了。

感谢所有回复的人，我希望这对以后的人有所帮助。

Answer 1

如果我理解正确的话：

def update_age(self):
    if self.__age <= len(self.__grow) - 1:
        c=0
        for i, n in enumerate(self.gTime):
            if abs(self.gTime[i] - self.vTime[i]) >= self.__grow[str(self.__age)][i]:
                self.vTime = copy.deepcopy(self.gTime)
                c += 1
        if(c==i+1):
            self.__age += 1
    else:
        pass

根据您的说法 - 我也会放弃 abs()，但这与整体处理无关，只是一种简化...

列表中相同位置对象的计算和比较

Calculation and comparison of objects in lists in the same position

python

python-3.x

python-3.7