优化 dict 生成的嵌套 for 循环 Python 3

Question

I am developing a game with an infinite world. I have this function to generate chunks of it whenever I need them, and I just need to pass it the chunk coordinates and it will create and store a chunk inside a dictionary. This is the function:

def generate(self, chunkx, chunky):

    # print("Generating chunk at", chunkx, chunky)


    Z_INDEX = [0,1,2,3]

    floor_void_diff = 60
    mountain = floor_void_diff + 7
    high_mountain = mountain + 6

    factor = 1/200
    biome_factor = 1/300

    floor = {}
    items = {}
    chunk = (chunkx, chunky)

    if chunk not in self.chunks:

        # print("Generating chunk at {}".format(chunk))
        for y in range(chunky * core["world_gen"]["chunksize"], chunky * core["world_gen"]["chunksize"] + core["world_gen"]["chunksize"]):
            for x in range(chunkx * core["world_gen"]["chunksize"], chunkx * core["world_gen"]["chunksize"] + core["world_gen"]["chunksize"]):

                temperature = create_noise(8, x, y, 0.5, biome_factor, 0, 100, self.n1)
                humidity = create_noise(8, x, y, 0.5, biome_factor, 0, 100, self.n2)
                altitude = create_noise(8, x, y, 0.5, biome_factor, 0, 100, self.n3)

                climate = (temperature, altitude, humidity)

                # gen_biome(climate)

                i = create_noise(16, x, y, 0.5, factor, 0, 100, self.noise)
                if i >= floor_void_diff:
                    if i >= mountain:
                        if i >= high_mountain:
                            floor.update({(x, y): {"block" : Z_INDEX[3], "climate": climate}})
                        else:
                            floor.update({(x, y): {"block" : Z_INDEX[2], "climate": climate}})
                    else:
                        floor.update({(x, y): {"block" : Z_INDEX[1], "climate": climate}})

                    spawner = random.randint(-1, core["world_gen"]["item_spawn"])
                    random_item = random.randint(0, len(core["item_list"])-1)

                    if spawner == 0:
                        items.update({(x, y): core["item_list"][random_item]})

                elif i < floor_void_diff:
                    floor.update({(x, y): {"block" : Z_INDEX[0], "climate": climate}})
                else:
                    floor.update({(x, y): EMPTY})

        self.chunks.update({chunk: {"floor": floor, "items": items}})
        self.unsaved += 1

this creates something like this:

self.chunks = {
(0,0): {
    "floor": {
        "block": 3,
        "climate": (23, 15, 87)
        },
    "items": {
        (2, 3): "rock"
        }
    }
}

to create it chunk the game takes up to half a second, which is not ideal. Is there any way I can optimize this to make it run faster? Something like a numpy function or a way to thread this and make it run in the background?

Answer 1

You could take a look at Numba package. It is an JIT compiler, which converts Python code to machine code using LLVM compiler. Just use @jit decorator before your loop and it might help. http://numba.pydata.org