CN110737409A - 数据加载方法、装置和终端设备 - Google Patents

Abstract

本发明提供了一种数据加载方法、装置和终端设备；方法包括：对目标python文件进行编译；如果接收到数据查询指令，从中提取关键字；判断关键字对应的数据是否已加载至内存；如果否，确定关键字对应的数据的固定量对应的子函数；执行确定的子函数，通过确定的子函数确定关键字对应的数据的固定量在父函数中的存储位置；从存储位置提取关键字对应的数据的固定量，根据提取的固定量，输出关键字对应的数据；将关键字对应的数据加载至内存。该方式中，将生成数据所需的固定量在保存在模块层的父函数中，在加载数据时子函数只需调用父函数中获取相应的固定量，进而输出固定量对应的数据，可以有效减少加载进内存的数据量，从而降低内存的消耗。

Description

数据加载方法、装置和终端设备

技术领域

本发明涉及数据处理技术领域，尤其是涉及一种数据加载方法、装置和终端设备。

背景技术

相关技术中，为了避免游戏数据表占用过多的内存，可以将数据表划分为多个数据块，仅将使用到的数据对应的数据块添加至内存中，但是，如果数据块太大，依然会加载过多无用的数据进内存，占用较多内存，如果数据块太小，会延长数据加载时间，甚至造成游戏性能下降；总之，以数据块为单位的数据加载方式，不能有效地降低内存的消耗。

发明内容

本发明的目的在于提供一种数据加载方法、装置和终端设备，以有效降低数据加载过程中内存的消耗。

第一方面，本发明实施例提供了一种数据加载方法，方法包括：对目标python文件进行编译，得到位于模块层的父函数，以及父函数的子函数，父函数中包括python文件中的固定量，且python文件中的固定量与各个子函数相对应；如果接收到数据查询指令，从数据查询指令中提取关键字；判断关键字对应的数据是否已加载至内存；如果否，确定关键字对应的数据的固定量对应的子函数；执行确定的子函数，通过确定的子函数确定关键字对应的数据的固定量在父函数中的存储位置；从存储位置提取关键字对应的数据的固定量，根据提取的固定量，输出关键字对应的数据；将关键字对应的数据加载至内存。

在本发明较佳的实施例中，上述确定关键字对应的数据的固定量对应的子函数的步骤，包括：计算关键字的哈希值；按照预设的规模值对哈希值进行取模，得到取模结果；将取模结果对应的子函数，确定为关键字对应的数据的固定量对应的子函数。

在本发明较佳的实施例中，上述执行确定的子函数，包括：执行确定的子函数中与关键字对应数据的固定量相关的字节码，字节码的操作参数包括关键字对应的数据的固定量在父函数中的存储位置。

在本发明较佳的实施例中，上述固定量包括常数类型的固定量、字符串类型的固定量。

在本发明较佳的实施例中，上述执行确定的子函数中与关键字对应数据的固定量相关的字节码的步骤，包括：如果固定量为常数类型的固定量，并且确定的子函数包含与常数类型的固定量相关联的字节码，从模块层中的父函数中，字节码的操作参数指示的对应位置获取常数类型的固定量；上述根据提取的固定量，输出关键字对应的数据的步骤，包括：通过字节码的操作指令，处理获取到的常数类型的固定量，得到关键字对应的数据。

在本发明较佳的实施例中，上述从模块层中的父函数中，字节码的操作参数指示的对应位置获取常数类型的固定量的步骤，包括：通过预设的MAKE_FUNCTION字节码，从模块层中的父函数中，字节码的操作参数指示对应位置获取常数类型的固定量。

在本发明较佳的实施例中，上述执行确定的子函数中与关键字对应数据的固定量相关的字节码的步骤，包括：如果固定量为字符串类型的固定量，并且确定的子函数包含与字符串类型的固定量相关联的字节码，判断确定的子函数中是否存在与字符串类型的固定量相关联的索引标识；如果不存在，从模块层中的父函数中，字节码的操作参数指示的对应位置获取字符串类型的固定量；将字符串类型的固定量存储至内存中的字符串列表中；在确定的子函数中添加与字符串类型的固定量相关联的索引标识；如果存在，从内存中的字符串列表中，索引标识对应的位置获取字符串类型的固定量。

在本发明较佳的实施例中，上述内存中预设有延迟加载器；上述将关键字对应的数据加载至内存的步骤，包括：通过延迟加载器，将关键字对应的数据加载至延迟加载器的字典中。

在本发明较佳的实施例中，上述将关键字对应的数据加载至内存的步骤之后，方法还包括：从内存中释放执行后的子函数。

第二方面，本发明实施例还提供一种数据加载装置，装置包括：文件编译模块，用于对目标python文件进行编译，得到位于模块层的父函数，以及父函数的子函数，父函数中包括python文件中的固定量，且python文件中的固定量与各个子函数相对应；关键字提取模块，用于如果接收到数据查询指令，从数据查询指令中提取关键字；第一判断模块，用于判断关键字对应的数据是否已加载至内存；子函数确定模块，用于如果否，确定关键字对应的数据的固定量对应的子函数；子函数执行模块，用于执行确定的子函数，通过确定的子函数确定关键字对应的数据的固定量在父函数中的存储位置；数据输出模块，用于从存储位置提取关键字对应的数据的固定量，根据提取的固定量，输出关键字对应的数据；数据加载模块，用于将关键字对应的数据加载至内存。

第三方面，本发明实施例提供了一种终端设备，包括处理器和存储器，存储器存储有能够被处理器执行的计算机可执行指令，处理器执行计算机可执行指令以实现上述数据加载方法的步骤。

第四方面，本发明实施例提供了一种计算机可读存储介质该计算机可读存储介质存储有计算机可执行指令，该计算机可执行指令在被处理器调用和执行时，计算机可执行指令促使处理器实现上述数据加载方法的步骤。

本发明实施例带来了以下有益效果：

本发明实施例提供的数据加载方法、装置和终端设备，在编译目标python文件的过程中，将生成数据所需的固定量保存在python文件模块层的父函数中；当接收到数据查询指令时，基于该指令确定关键字，当该关键字对应的数据没有加载到内存时，执行确定的子函数，通过子函数确定固定量在父函数中的存储位置，以提取对应的固定量，输出关键字对应的数据并将数据加载至内存。该方式中，将生成数据所需的固定量在保存在模块层的父函数中，在加载数据时只需调用父函数中获取相应的固定量，进而输出固定量对应的数据，该方式可以有效减少加载进内存的数据量，从而降低内存的消耗。

本发明的其他特征和优点将在随后的说明书中阐述，或者，部分特征和优点可以从说明书推知或毫无疑义地确定，或者通过实施本公开的上述技术即可得知。

为使本公开的上述目的、特征和优点能更明显易懂，下文特举较佳实施例，并配合所附附图，作详细说明如下。

附图说明

为了更清楚地说明本发明具体实施方式或现有技术中的技术方案，下面将对具体实施方式或现有技术描述中所需要使用的附图作简单地介绍，显而易见地，下面描述中的附图是本发明的一些实施方式，对于本领域普通技术人员来讲，在不付出创造性劳动的前提下，还可以根据这些附图获得其他的附图。

图1为本发明实施例提供的一种数据加载方法的流程图；

图2为本发明实施例提供的另一种数据加载方法的流程图；

图3为本发明实施例提供的一种常数类型的固定量保存在模块层的示意图；

图4为本发明实施例提供的另一种数据加载方法的流程图；

图5为本发明实施例提供的另一种数据加载方法的流程图；

图6为本发明实施例提供的另一种数据加载方法的流程图；

图7为本发明实施例提供的一种数据加载装置的结构示意图；

图8为本发明实施例提供的一种终端设备的结构示意图。

具体实施方式

下面将结合实施例对本发明的技术方案进行清楚、完整地描述，显然，所描述的实施例是本发明一部分实施例，而不是全部的实施例。基于本发明中的实施例，本领域普通技术人员在没有做出创造性劳动前提下所获得的所有其他实施例，都属于本发明保护的范围。

在游戏开发中，Python配置表项是一种常用的数据配置方法。在Python的存储结构中对一些小的整型值(比如小于256的整型值)有共享内存的优化。对静态的字符串值，在进行预编译时有intern优化。除此之外，Python对重复数据没有其他内存上的优化。但是在Python的配置表项中会有大量重复的浮点数，整数，元表和字典存在。在游戏实际的运行过程中，这造成了大量的内存浪费。

另外，Python配置表通常会有几千到几万不等的数据项，每个数据项由一个关键字作为key值，数据体作为value值。这些配置表项通常用于游戏中的数据查询，但是在一次游戏的体验过程中实际查询的数据表项在5-10％以内，有90％以上的数据加载进了内存但是并没有实际的查询。Python在对字典格式分配空间按照以下公式分配：2^ceil(log2(n))，即分配空间为能n个数据的最小的2的幂级(举例来说，数据为100，分配空间128；数据为33，分配空间64)。也就是说Python数据项越多，占用的存储空间浪费越严重。这也在另一方面造成了Python数据表项的内存暴涨。

现有的数据加载方案，当接收到数据查询指令后，会将数据配置表载入到内存中，从数据配置表获得对应的数据，并进行调用。这种方法随着数据的越来越多，会导致数据配置表占用的内存逐渐增加，尤其对于手机来说内存有限，则数据配置表查询数据的方式会导致内存利用率较低。

针对现有的数据加载方案存在内存利用率较低的问题，通常有两种优化方案：一种是Lazy Import的技术方案，另一种是元表代替字典的技术方案。其中，Lazy Import的技术方案是指将数据表划分为多个数据块，仅将使用到的数据对应的数据块添加至内存中，但是，如果数据块太大，依然会加载过多无用的数据进内存，占用较多内存，如果数据块太小，会延长数据加载时间，甚至造成游戏性能下降；总之，以Lazy Import的技术方案，不能有效地降低内存的消耗。

上述元表代替字典的技术方案，会破坏字典结构，并且增加了查询元表的时间。虽然可以进行一定比例的压缩，但是压缩的效果并不明显，而且，引入的元表结构在value值较少的时候可能比字典结构更大，增加内存的消耗。这是因为实际空间的分配数量要多于数据的数量，会造成分配空间的浪费。

总之，现有的数据加载方法以及其优化方案均对于内存的利用率较低，不能有效地降低内存的消耗，基于此，本发明实施例提供一种数据加载方法、装置和终端设备，该技术应用于手机、平板电脑、台式电脑、游戏机等可以实现人机交互的设备上，尤其可以适用于手机游戏场景中，如射击游戏、卡牌游戏、竞技游戏、音乐游戏中。

为便于对本实施例进行理解，首先对本发明实施例所公开的一种数据加载方法进行详细介绍。参见图1所示的一种数据加载方法的流程图，该方法包括如下步骤：

步骤S102，对目标python文件进行编译，得到位于模块层的父函数，以及上述父函数的子函数，上述父函数中包括上述python文件中的固定量，且上述python文件中的固定量与各个子函数相对应。

本实施例中的python文件的父函数位于模块层(也可以称为Module层)，父函数包括多个固定量；每个固定量保存在模块层的对应位置上，不同位置上保存的固定量不同；且固定量与子函数相对应。

其中，python是一种计算机程序设计语言，具体的说，是一种面向对象的动态类型语言。通过python语言编译得到的文件就是python文件；python文件的模块层是一组功能的组合，实质上就是一个包含了python定义和声明的文件。

上述子函数可以是指组织好的、可重复使用的、用来实现单一或相关联功能的代码段。上述固定量可以理解为该子函数中需要用到的常量或者该子函数中的字符串类型。每个函数中都会有很多的固定量，这些固定量可能相同，也可能不同，将这些固定量去重后保存在位于模块层的父函数的对应位置上。

其中，固定量去重指的是将重复的固定量只保留一个，保证模块层的不同位置上保存的固定量不同，不存在重复的固定量。固定量保存在父函数中，而子函数包括固定量的位置信息，因此可以通过子函数调用固定量。子函数中还包括字节码，字节码可以理解为包含一个执行程序的二进制文件，用于对固定量进行特定的计算操作。

步骤S104，如果接收到数据查询指令，从该数据查询指令中提取关键字。

该数据查询指令用于调用或者查询某个数据，将被调用的数据加载至内存。数据查询指令包括关键字，根据该关键字可以确定被调用的数据。因此，需要从数据查询指令中提取关键字，方便确定被调用的数据。例如，查询指令为“查询普通攻击的穿刺几率”，关键字可以为“普通攻击”、“穿刺”和“几率”。

步骤S106，判断上述关键字对应的数据是否已加载至内存。

根据关键字，可以确定被调用的数据是否已经提前加载到内存中。确定的方法可以为遍历内存中的所有数据，判断内存中的数据是否包括上述关键字，如果包括，则上述关键字对应的数据已经加载至内存；如果不包括，则上述关键字对应的数据没有加载至内存。如果数据已经提前加载到内存中，则直接从内存中调用该数据即可；如果数据没有提前加载到内存中，即内存中不存在该数据，则需要查询到该数据，并将该数据加载至内存，从内存中调用该数据。

步骤S108，如果否，确定关键字对应的数据的固定量对应的子函数。

当关键字对应的数据没有提前加载至内存时，需要找到该数据的位置并调用。python文件中的数据通过子函数调用，因此需要首先确定关键字对应的数据的子函数。在需要该数据时只需调用该子函数，不需要调用包括所有数据的数据表，因此可以压缩数据，降低内存的消耗。在实际实现时，子函数可以包括一些关键字，当子函数包括的关键字与数据查询指令包括的关键字相同或者相应时，确定该子函数为数据查询指令包括的关键字对应的数据的子函数。

步骤S110，执行确定的子函数，通过该确定的子函数确定关键字对应的数据的固定量在父函数中的存储位置。

在确定该数据对应的子函数后，执行该子函数，该子函数中的固定量保存在了模块层的父函数中，子函数只保存了固定量在父函数保存的位置信息，因此在确定了子函数后，根据子函数中包括的位置信息可以确定所需的固定量在父函数中的存储位置。

步骤S112，从存储位置提取关键字对应的数据的固定量，根据提取的固定量，输出关键字对应的数据。

确定了固定量在父函数中的存储位置之后，通过该存储位置从父函数提取固定量，子函数再基于该固定量输出关键字对应的数据。这样就得到了关键字对应的数据。因为父函数只保存去重后的固定量，即父函数不存在重复的固定量，则起到了压缩固定量的作用，可以降低内存的消耗。

例如，子函数包括固定量存放于模块层的位置信息，根据该位置信息即可确定固定量的存储位置，提取该固定量后，将该固定量与子函数组合，关键字对应的数据保存在组合后的子函数中，根据该组合后的子函数即可调用该数据。

步骤S114，将关键字对应的数据加载至内存。

在获得关键字对应的数据后，将该数据加载至内存，以方便之后调用该数据。

本发明实施例提供的一种数据加载方法，在编译目标python文件的过程中，将生成数据所需的固定量保存在python文件模块层的父函数中；当接收到数据查询指令时，基于该指令确定关键字，当该关键字对应的数据没有加载到内存时，执行确定的子函数，通过子函数确定固定量在父函数中的存储位置，以提取对应的固定量，输出关键字对应的数据并将数据加载至内存。该方式中，将生成数据所需的固定量在保存在模块层的父函数中，在加载数据时只需调用从父函数中获取相应的固定量，进而输出固定量对应的数据，该方式可以有效减少加载进内存的数据量，从而降低内存的消耗。

本发明实施例还提供另一种数据加载方法；该方法在上述实施例方法的基础上实现；该方法重点描述确定关键字对应的数据的固定量对应的子函数的具体实现方式。

如图2所示的另一种数据加载方法的流程图，该方法包括如下步骤：

步骤S202，对目标python文件进行编译，得到位于模块层的父函数，以及上述父函数的子函数，上述父函数中包括上述python文件中的固定量，且上述python文件中的固定量与各个子函数相对应。

步骤S204，如果接收到数据查询指令，从该数据查询指令中提取关键字。

步骤S206，判断上述关键字对应的数据是否已加载至内存。如果否，则执行步骤S208；如果是，则结束。

步骤S208，计算上述关键字的哈希值。

该哈希值通过哈希函数计算得到，哈希函数也可以称为散列函数或者散列算法。哈希函数是一种从任何一种数据中创建小的数字“指纹”的方法。哈希值一般通过哈希值算法计算得到，不同关键字的哈希值不同。每一个关键字都有对应的哈希值，主要用于判断两个关键字是否相同。

步骤S210，按照预设的规模值对该哈希值进行取模，得到取模结果。

上述预设的规模值决定了数据的命中粒度。预设的规模值越小，一次加载进的数据越多，同时可能浪费的内存也就越多。一般来说，预设的规模值一般为数据表的长度。数据表是指数据保存在子函数前，由数据组成的数据表。也就是说，以数据表的长度为规模值，可以让每个数据保存在一个子函数中。取模是指用该哈希值除以预设的规模值，得到的余数就是取模结果。取模结果可以确定该数据存储在哪个子函数中，找到该数据存储的子函数的位置。例如：假设关键字计算得到的哈希值为100，预设的规模值为9，则100/9的余数为1(即100＝9×11+1)，1就是取模结果。

步骤S212，将该取模结果对应的子函数，确定为关键字对应的固定量的子函数。

取模结果对应的子函数，就是保存关键字对应的固定量对应的子函数，将该子函数确定为键字对应的数据的子函数。仍然以上面的例子进行说明，取模结果为1后，按照预先设定的映射关系，找到取模结果为1对应的子函数，该子函数就是关键字对应的数据的子函数。

步骤S214，执行确定的子函数，通过该确定的子函数确定关键字对应的数据的固定量在父函数中的存储位置。

通过执行子函数确定固定量在父函数的存储位置，由于子函数包括的字节码中具有固定量的存储位置，因此，可以通过执行字节码来确定关键字对应的数据的固定量在父函数汇总的存储位置，可以通过以下步骤执行：

执行确定的子函数中与关键字对应数据的固定量相关的字节码，字节码的操作参数包括关键字对应的数据的固定量在父函数中的存储位置。

子函数中包括字节码，字节码用于对固定量进行特定的计算操作；其中，字节码的操作参数包括了关键字对应的数据的固定量在父函数中的存储位置。因此，执行关键字对应的数据的固定量相关的字节码，可以根据字节码的操作参数包括的存储位置从父函数中确定关键字对应的数据的固定量。

固定量的类型不同，执行确定的子函数中与关键字对应数据的固定量相关的字节码的步骤不同。固定量按照类型分为常数类型的固定量和/或字符串类型的固定量，需要说明的是，常数类型的固定量和字符串类型的固定量可以同时存在，也可以只存在一种。

步骤S216，从存储位置提取关键字对应的数据的固定量，根据提取的固定量，输出关键字对应的数据。

步骤S218，将关键字对应的数据加载至内存。

上述方式中，通过计算关键字的哈希值，按照预设的规模值对该哈希值取模以确定子函数，并将该子函数作为关键字对应的固定量对应的子函数。通过计算哈希值并进行取模的方法可以准确地确定关键字对应的固定量对应的子函数。

本发明实施例还提供另一种数据加载方法；该方法在上述实施例方法的基础上实现；该方法重点描述对于常数类型的固定量，执行确定的子函数的具体实现方式，之后再说明固定量包括常数类型的固定量时，数据加载的具体方法。如图4所示的另一种数据加载方法的流程图，该方法包括如下步骤：

步骤S402，对目标python文件进行编译，得到位于模块层的父函数，以及上述父函数的子函数，上述父函数中包括上述python文件中的固定量，且上述python文件中的固定量与各个子函数相对应。

步骤S404，如果接收到数据查询指令，从该数据查询指令中提取关键字。

步骤S406，判断上述关键字对应的数据是否已加载至内存。如果否，则执行步骤S408；如果是，则结束。

步骤S408，确定关键字对应的数据的固定量对应的子函数。

步骤S410，如果固定量为常数类型的固定量，并且确定的子函数包含与常数类型的固定量相关联的字节码，从模块层中的父函数中，字节码的操作参数指示的对应位置获取常数类型的固定量。

常数类型的固定量也可以称为指const固定量，即子函数中需要用到的常量；字符串类型的固定量，是指代表不同字符串类型的固定量，包括：Interned类型和StringRef类型。

当子函数被调用时，父函数内部存储的固定量才会随着字节码的执行而展开，以达到解码的目的。字节码可以理解为包含一个执行程序的二进制文件。因此，在执行子函数时，需要执行字节码，子函数中，与固定量相关联的字节码的操作参数包括：字节码所需的固定量位于模块层的对应位置。该对应位置具体可以通过模块层的存储空间中各个空间地址表示。该字节码所需的固定量保存在模块层，当执行子函数并需要执行字节码时，只需要从模块层的对应位置调用对应的固定量即可执行字节码。

下面首先说明固定量包括常数类型的固定量时，数据加载的具体方法。在Python中一个PyCodeObject可以理解为函数或模块，PyCodeObject中的const可以理解为在本函数中需要用到的常量，也就是常数类型的固定量。举例来说：

Data＝{}

Def func():

Data[‘abc’]＝[1,2,3]

Def gunc():

Data[‘xyz’]＝[2,3,4]

在上述代码中，函数func对应的PyCodeObject中const里存的是一个列表,内容为[‘abc’,1,2,3]，在函数gunc对应的PyCodeObject中const里存的是一个列表，内容为[‘xyz’,2,3,4]。函数func和函数gunc中的const都存储了2和3两个值，这些值的存储是需要占用空间的。所以改进的目标是把这些const值整合在模块层中，同样的const只占用一个位置。因此，需要预先将字节码存贮在子函数中，并且，将子函数的const保存在模块层中。

具体来说，对于const值，即常数类型的固定量保存在子函数对应的子PyCodeObject所属的父PyCodeObject中。PyCodeObject是有父子结构的，在一个模块中定义的子函数，它对应的PyCodeObject会存储在模块层的父PyCodeObject中。所以，优化的目的是把函数中的const常量去重后合并到模块层的父PyCodeObject中。也就是说，将所有子函数对应的PyCodeObject中的const提取出来，去重后，放入模块层的父PyCodeObject中的指定位置。

对于常数类型的固定量的模块层保存方法，可以参见图3所示的一种常数类型的固定量保存在模块层的示意图，图3中的(a)表示未将固定量保存在模块层前，模块层PyCodeObject只保存有两个子函数PyCodeObject_func和PyCodeObject_gunc，而子函数PyCodeObject_func和PyCodeObject_gunc的固定量没有保存在模块层PyCodeObjec中，其中PyCodeObject_func的固定量有‘abc’、1、2、3，PyCodeObject_gunc的固定量有‘xyz’、2、3、4。

图3中的(b)为保存后的示意图，子函数PyCodeObject_func和PyCodeObject_gunc的固定量保存在模块层PyCodeObjec中，即‘abc’、1、2、3、4，对于固定量2和3在两个子函数中均出现，但是也仅仅在模块层中保存一次，以达到节约空间的目的。

举例说明数据加载过程前的通过子函数保存python文件中的数据转换方法，以下面代码为例：

#-☆-coding：utf-8-☆-

#表头定义：skill_def.py，输入文件：技能数据表.xls-技能-主动技能，输出文件：skill.py

data＝{

(1000,1)：{‘desc’:‘普通攻击有25％几率穿刺伤害。’，‘name’：‘穿刺’，‘level’：1，‘hurt_type’：(10,13)，‘is_active’：True}

(1000,2)：{‘desc’:‘普通攻击有30％几率穿刺伤害。’，‘name’：‘穿刺’，‘level’：2，‘hurt_type’：(10,13)，‘is_active’：True}

}

以上面的python数据表为例，python中{}里的数据是字典，读取数据是以(1000,1)或者(1000,2)为关键字，获取对应的数据项的过程。Python总要读取这张表首先要导入(Import)这张表，导入的过程就已经在分配内存空间了，后续不论是否读取这个表内存都已经占用。

对上面的python数据表进行转换，转换后的结果如下所示：

import sys

from LazyImporter import LazyImporter

data＝LazyImporter(sys.modules[__name__])

def f1():

global data

data[(1000,1)]＝{‘desc’:‘普通攻击有25％几率穿刺伤害。’，‘name’：

‘穿刺’，‘level’：1，‘hurt_type’：(10,13)}

def f2():

global data

data[(1000,1)]＝{‘desc’:‘普通攻击有30％几率穿刺伤害。’，‘name’：‘穿刺’，‘level’：2，‘hurt_type’：(10,13)}

转换后的python数据表将上表的数据分别分解到两个子函数f1()和f2()中，每一个函数封装了一个数据，f1()封装data[(1000,1)]；f2()封装data[(1000,2)]。即通过子函数f1()和f2()，保存了上面python数据表的数据。

其中，代码中的LazyImporter为延迟加载器，延迟加载器继承于字典，初始状态下延迟加载器的内部的数据为空字典，当有数据值查询时首先判断是否已经在当前字典中。如果数据已经在当前字典中，直接返回数据值，与字典无异。如果数据不在当前字典中，则调用保存该数据的子函数，将数据加载进内存。

对于执行常数类型的固定量对应的字节码的步骤，只需要依据字节码的操作参数指示的对应位置从父函数中获取常数类型的固定量即可。该字节码包括LOAD_CONST。因为预先已经将所有子函数的固定量全部去重并保存到父函数中，LOAD_CONST解码需要重新定向，对每个PyCodeObject的co_code进行解析，如果op操作为LOAD_CONST，则替换oparg为相对应的const在新的consts表里的位置。其中，co_code是Python字节码，每个字节码包括操作指令op和参数oparg。每个字节码的oparg的意义不同，对于LOAD_CONST这个字节码，oparg是指在consts中的索引。

上文已经说明，python文件中子函数所需的常数类型的固定量保存在子函数对应的父函数中，因此，从子函数对应的父函数中，字节码的操作参数指示的对应位置获取常数类型的固定量。

在完成与常数类型的固定量相关联的字节码的重定向后，即可以在父PyCodeObject中根据该字节码的操作参数指示的对应位置获取常数类型的固定量。

上述获取常数类型的固定量的步骤，是通过预设的MAKE_FUNCTION字节码实现的。即通过预设的MAKE_FUNCTION字节码，从模块层中的父函数中，字节码的操作参数指示对应位置获取常数类型的固定量。

因为模块层有大量的函数定义，所以在模块层会有很多MAKE_FUNCTION字节码，默认的MAKE_FUNCTION字节码会将当前函数对象的常数类型的固定量设置成子PyCodeObject的常数类型的固定量。这里预设的MAKE_FUNCTION字节码需要对原有的MAKE_FUNCTION字节码进行修改，预设的MAKE_FUNCTION字节码也称作MAKE_FUNCTIONO_EX字节码，作用是将子PyCodeObject的常数类型的固定量指向父PyCodeObject的常数类型的固定量。函数的常数类型的固定量被修改为了父PyCodeObject的常数类型的固定量，子PyCodeObject的在哈希计算需要屏蔽常数类型的固定量，否则会在计算哈希值时形成死循环。

步骤S412，通过字节码的操作指令，处理获取到的常数类型的固定量，得到关键字对应的数据。

在从模块层中的父函数(即父PyCodeObject)获取常数类型的固定量后，根据得到的常数类型的固定量并通过字节码的操作指令，得到关键字对应的数据。

步骤S414，将关键字对应的数据加载至内存。

上述方式中，固定量包括常数类型的常数类型的固定量时，子函数包含与常数类型的固定量相关联的字节码，根据字节码的操作参数获取常数类型的固定量，处理后得到关键字对应的数据。预先将参数类型的常数类型的固定量去重并保存到模块层中，并且根据预设的MAKE_FUNCTION字节码从模块层的父函数中获取常数类型的固定量。可以准确地获得常数类型的固定量，并且压缩了保存的空间，以降低内存的消耗。

本发明实施例还提供另一种数据加载方法；该方法在上述实施例方法的基础上实现；该方法重点描述执行对于字符串类型的固定量，执行确定的子函数的具体实现方式，之后再说明固定量包括字符串类型的字符串类型的固定量时，数据加载的具体方法。

字符串类型的字符串类型的固定量可以表示为String，也可以称为字符串，String包括Interned类型和StringRef类型。在进行数据加载之前，需要先对python文件中所有出现过的PyStringObject对象进行统计，这其中包括所有类型为Interned的PyStringObject；还需要将所有的元表和PyCodeObject展开进行PyStringObject的搜索。这里是指对PyCodeObject中const的值进行展开，还有其他数据结构中可能包含StringObject对象的进行展开，以进行PyStringObject的搜索和收集。

在Python中每个String(字符串)都是一个PyStringObject。在一个文件加载过程中，因为可能会有一个字符串在PyCodeObject中出现多次的问题，为了节省内存，Python引入了Intern的机制。

比如‘abc’这个String，第一次出现的时候，Python需要将它加载进内存，它会标记它加载的是Intern的String，即需要加载实际的String对象，加载完成后把这个String丢到一个队列list中。第二次遇到加载这个‘abc’的时候，Python的字节码会提示去加载StringRef，这个ref就是在这个队列list中的索引值。这样就不用再次创建PyStringObject，直接使用上一次创建的那个就可以了。

如图5所示的另一种数据加载方法的流程图，该方法包括如下步骤：

步骤S502，对目标python文件进行编译，得到位于模块层的父函数，以及上述父函数的子函数，上述父函数中包括上述python文件中的固定量，且上述python文件中的固定量与各个子函数相对应。

步骤S504，如果接收到数据查询指令，从该数据查询指令中提取关键字。

步骤S506，判断上述关键字对应的数据是否已加载至内存。如果否，则执行步骤S508；如果是，则结束。

步骤S508，确定关键字对应的数据的固定量对应的子函数。

步骤S510，如果固定量为字符串类型的固定量，并且确定的子函数包含与字符串类型的固定量相关联的字节码，判断确定的子函数中是否存在与字符串类型的固定量相关联的索引标识；如果不存在，则执行步骤S512；如果存在，则执行步骤S514。

对于一个字符串，在第一次加载的时候将该字符串标识为interned类型的字符串，对于该interned类型的字符串，子pycodeobject按照上述处理方式获取该字符串，然后将该字符串放入内存中的stringintern表中，并告知该子函数这个字符串在stringintern表中的索引标识；如果该字符串再次需要加载时，子函数已经知晓了该字符串在stringintern表中的索引，该字符串被标识为stringref类型的字符串，通过前述索引从stringintern表中获取字符串，不再按照上述处理方式从module层获取。

也就是说，存在与字符串类型的固定量相关联的索引标识的字符串为stringref类型的字符串，不存在与字符串类型的固定量相关联的索引标识的字符串为interned类型的字符串。

步骤S512，从模块层中的父函数中，字节码的操作参数指示的对应位置获取字符串类型的固定量；将字符串类型的固定量存储至内存中的字符串列表中；在确定的子函数中添加与字符串类型的固定量相关联的索引标识。

上述步骤S512为interned类型的字符串的字节码执行的步骤，该字节码不包括索引标识，因此需要从操作参数指示的父函数中的对应位置获取字符串类型的固定量。并且，将获取的固定量保存在内存中的字符串列表(stringintern表)中，并且将该字符串列表(stringintern表)的索引标识添加到子函数中，以方便下一次固定量的获取。

步骤S514，从内存中的字符串列表中，索引标识对应的位置获取字符串类型的固定量。

上述步骤S514为stringref类型的字符串的字节码执行的步骤，该字节码包括索引标识，因此无需从父函数中获取固定量，只需要根据索引标识从字符串列表(stringintern表)中即可确定固定量。

步骤S516，根据提取的固定量，输出关键字对应的数据。

步骤S518，将关键字对应的数据加载至内存。

上述方式中，固定量包括字符串类型的字符串类型的固定量时，首先判断确定子函数中是否存在与字符串类型的固定量相关联的索引标识，如果不存在，则从模块层的父函数中，字节码的操作参数指示的对应位置获取字符串类型的固定量；如果存在，则根据索引标识从字符串列表(stringintern表)中获取字符串类型的固定量。针对不同的字符串类型的固定量类型采用不同的方法获得字符串类型的固定量，可以准确地获得字符串类型的固定量，并且压缩了保存的空间，以降低内存的消耗。

本发明实施例还提供另一种数据加载方法；该方法在上述实施例方法的基础上实现；该方法重点描述将关键字对应的数据加载至内存的具体实现方式。

如图6所示的另一种数据加载方法的流程图，该方法包括如下步骤：

步骤S602，对目标python文件进行编译，得到位于模块层的父函数，以及上述父函数的子函数，上述父函数中包括上述python文件中的固定量，且上述python文件中的固定量与各个子函数相对应。

python文件对应的程序启动后，需要将编译后的目标python文件的模块层加载至内存中，模块层包括了python文件中子函数所需的固定量，模块层存储的固定量不存在相同的固定量。因此将python文件的模块层加载至内存中，可以更加快速地从模块层的对应位置提取子函数所需的固定量。

步骤S604，如果接收到数据查询指令，从该数据查询指令中提取关键字。

步骤S606，判断上述关键字对应的数据是否已加载至内存。如果否，则执行步骤S608；如果是，则结束。

步骤S608，确定关键字对应的数据的固定量对应的子函数。

步骤S610，执行确定的子函数，通过该确定的子函数确定关键字对应的数据的固定量在父函数中的存储位置。

步骤S612，通过延迟加载器，将上述关键字对应的数据加载至延迟加载器的字典中。

通过内存预设的延迟加载器进行加载。初始状态下延迟加载器的内部的数据为空字典，当有数据值查询时首先判断是否已经在当前字典中。如果数据已经在当前字典中，直接返回数据值，与字典无异。如果数据不在当前字典中，则调用保存该数据的子函数，将数据加载进内存，即利用关键字检出对应的哈希值，并以预设的规模值为底取模，计算出存储数据的子函数的名称，调用该子函数并将数据加载至内存。其中，预设的规模值一般取数据表的长度。通过延迟加载器将数据加载至内存，可以提升加载的效率，并且降低内存的消耗。

另外，在实际使用的过程中，还可以将子函数中的name字段替换为空。因为name字段只用于函数名称的显示，在子函数中是无用的，可以全部替换为空。Python有自省机制，可以调用一个函数的func.__name__方法查询函数名称。这里因为我们使用的函数都是临时函数，可以省去name的空间占用。将name字段替换为空，也是为了节约内存。

步骤S614，从内存中释放执行后的子函数。

释放子函数，就是不再在内存中执行该子函数；该子函数的压缩数据还在内存中。在数据加载至内存后，便可以将子函数从内存中释放，可以节约内存。

上述方式中，在内存中预设有延迟加载器，通过延迟加载器加载数据；数据加载至内存后释放执行的子函数；接收到数据查询指令的步骤之前，如果python文件对应的程序启动，将python文件的模块层加载至内存中。可以更加快速地从模块层的对应位置提取子函数所需的固定量，增加加载速度，并且降低内存消耗。

本实施例提供的数据加载方法的加载速度，可以参见表1所示的一种数据加载速度对比表，如表1所示：

Standard(s)	Lazy Opt(s)	Percentage
			0.128	0.0373	29％

表1一种数据加载速度对比表

表1中的第一行Standard表示标准数据加载方法的加载速度，Lazy Opt表示为本实施例提供的数据加载方法的加载速度，Percentage表示为本实施例提供的数据加载方法的加载速度和标准数据加载方法的加载速度的比例。由表1可知：标准数据加载方法的加载速度为0.128秒，本实施例提供的数据加载方法的加载速度为0.0373秒，本实施例提供的数据加载方法的加载速度仅为标准数据加载方法的加载速度的29％(0.0373/0.128＝29％)。

本实施例提供的数据加载方法的数据压缩程度，可以参见表2所示的一种数据压缩程度对比表，如表2所示：

文件	Standard(MB)	Lazy Opt(MB)	Percentage
				hero_test_reward	49	8	16％
event_dialogue	5.6	3.6	64％
				monster	10.3	1.89	18％
skill	7.6	2.4	31％
				robot_attr	11.0	2.12	19％
event_content	3.5	1.33	38％
				hero_tresure	3.38	0.85	25％
Total	90.38	29.19	22.3％

表2一种数据压缩程度对比表

第一行中文件代表文件名，Standard表示标准数据加载方法的数据大小，LazyOpt表示为本实施例提供的数据加载方法的数据大小，Percentage表示为本实施例提供的数据加载方法的数据大小和标准数据加载方法的数据大小的比例。最后一行为上面7个文件的和，最后一行第二列表示标准数据加载方法的数据总和，最后一行第三列表示本实施例提供的数据加载方法的数据总和，最后一行第四列表示为本实施例提供的数据加载方法的数据总和与标准数据加载方法的数据总和的比例。

由表2可知：本实施例提供的数据加载方法的数据大小与标准数据加载方法的数据大小相比，仅占标准数据加载方法的数据大小的16％-68％，平均为22.3，即压缩比例为22.3％，本实施例提供的数据加载方法具有良好的数据压缩能力。

需要说明的是，上述各方法实施例均采用递进的方式描述，每个实施例重点说明的都是与其他实施例的不同之处，各个实施例之间相同相似的部分互相参见即可。

对应于上述方法实施例，本发明实施例提供了一种数据加载装置，如图7所示的一种数据加载装置的结构示意图，该装置包括：

文件编译模块71，用于对目标python文件进行编译，得到位于模块层的父函数，以及父函数的子函数，父函数中包括python文件中的固定量，且python文件中的固定量与各个子函数相对应；

关键字提取模块72，用于如果接收到数据查询指令，从数据查询指令中提取关键字；

第一判断模块73，用于判断关键字对应的数据是否已加载至内存；

子函数确定模块74，用于如果否，确定关键字对应的数据的固定量对应的子函数；

子函数执行模块75，用于执行确定的子函数，通过确定的子函数确定关键字对应的数据的固定量在父函数中的存储位置；

数据输出模块76，用于从存储位置提取关键字对应的数据的固定量，根据提取的固定量，输出关键字对应的数据；

数据加载模块77，用于将关键字对应的数据加载至内存。

本发明实施例提供的一种数据加载装置，在编译目标python文件的过程中，将生成数据所需的固定量保存在python文件模块层的父函数中；当接收到数据查询指令时，基于该指令确定关键字，当该关键字对应的数据没有加载到内存时，执行确定的子函数，通过子函数确定固定量在父函数中的存储位置，以提取对应的固定量，输出关键字对应的数据并将数据加载至内存。该方式中，将生成数据所需的固定量在保存在模块层的父函数中，在加载数据时只需调用父函数中获取相应的固定量，进而输出固定量对应的数据，该方式可以有效减少加载进内存的数据量，从而降低内存的消耗。

在一些实施例中，子函数确定模块，用于：计算关键字的哈希值；按照预设的规模值对哈希值进行取模，得到取模结果；将取模结果对应的子函数，确定为关键字对应的数据的固定量对应的子函数。

在一些实施例中，子函数执行模块，用于：执行确定的子函数中与关键字对应数据的固定量相关的字节码，字节码的操作参数包括关键字对应的数据的固定量在父函数中的存储位置。

在一些实施例中，固定量包括常数类型的固定量、字符串类型的固定量。

在一些实施例中，子函数执行模块，用于：如果固定量为常数类型的固定量，并且确定的子函数包含与常数类型的固定量相关联的字节码，从模块层中的父函数中，字节码的操作参数指示的对应位置获取常数类型的固定量；数据输出模块，用于：通过字节码的操作指令，处理获取到的常数类型的固定量，得到关键字对应的数据。

在一些实施例中，子函数执行模块，用于：通过预设的MAKE_FUNCTION字节码，从模块层中的父函数中，字节码的操作参数指示对应位置获取常数类型的固定量。

在一些实施例中，子函数执行模块，用于：如果固定量为字符串类型的固定量，并且确定的子函数包含与字符串类型的固定量相关联的字节码，判断确定的子函数中是否存在与字符串类型的固定量相关联的索引标识；如果不存在，从模块层中的父函数中，字节码的操作参数指示的对应位置获取字符串类型的固定量；将字符串类型的固定量存储至内存中的字符串列表中；在确定的子函数中添加与字符串类型的固定量相关联的索引标识；如果存在，从内存中的字符串列表中，索引标识对应的位置获取字符串类型的固定量。

在一些实施例中，内存中预设有延迟加载器；数据加载模块，用于：将关键字对应的数据加载至内存的步骤，包括：通过延迟加载器，将关键字对应的数据加载至延迟加载器的字典中。

在一些实施例中，上述装置还包括子函数释放模块，用于：从内存中释放执行后的子函数。

本发明实施例提供的数据加载装置，与上述实施例提供的数据加载装方法具有相同的技术特征，所以也能解决相同的技术问题，达到相同的技术效果。

本发明实施例还提供了一种终端设备，用于运行上述数据加载方法；参见图8所示的一种终端设备的结构示意图，该终端设备包括存储器100和处理器101，其中，存储器100用于存储一条或多条计算机指令，一条或多条计算机指令被处理器101执行，以实现上述数据加载方法。

进一步地，图8所示的终端设备还包括总线102和通信接口103，处理器101、通信接口103和存储器100通过总线102连接。

其中，存储器100可能包含高速随机存取存储器(RAM，Random Access Memory)，也可能还包括非不稳定的存储器(non-volatile memory)，例如至少一个磁盘存储器。通过至少一个通信接口103(可以是有线或者无线)实现该系统网元与至少一个其他网元之间的通信连接，可以使用互联网，广域网，本地网，城域网等。总线102可以是ISA总线、PCI总线或EISA总线等。总线可以分为地址总线、数据总线、控制总线等。为便于表示，图8中仅用一个双向箭头表示，但并不表示仅有一根总线或一种类型的总线。

处理器101可能是一种集成电路芯片，具有信号的处理能力。在实现过程中，上述方法的各步骤可以通过处理器101中的硬件的集成逻辑电路或者软件形式的指令完成。上述的处理器101可以是通用处理器，包括中央处理器(Central Processing Unit，简称CPU)、网络处理器(Network Processor，简称NP)等；还可以是数字信号处理器(DigitalSignal Processor，简称DSP)、专用集成电路(Application Specific IntegratedCircuit，简称ASIC)、现场可编程门阵列(Field-Programmable Gate Array，简称FPGA)或者其他可编程逻辑器件、分立门或者晶体管逻辑器件、分立硬件组件。可以实现或者执行本发明实施例中的公开的各方法、步骤及逻辑框图。通用处理器可以是微处理器或者该处理器也可以是任何常规的处理器等。结合本发明实施例所公开的方法的步骤可以直接体现为硬件译码处理器执行完成，或者用译码处理器中的硬件及软件模块组合执行完成。软件模块可以位于随机存储器，闪存、只读存储器，可编程只读存储器或者电可擦写可编程存储器、寄存器等本领域成熟的存储介质中。该存储介质位于存储器100，处理器101读取存储器100中的信息，结合其硬件完成前述实施例的方法的步骤。

本发明实施例还提供了一种计算机可读存储介质，该计算机可读存储介质存储有计算机可执行指令，该计算机可执行指令在被处理器调用和执行时，计算机可执行指令促使处理器实现上述数据加载方法，具体实现可参见方法实施例，在此不再赘述。

本发明实施例所提供的数据加载方法、装置和终端设备的计算机程序产品，包括存储了程序代码的计算机可读存储介质，程序代码包括的指令可用于执行前面方法实施例中的方法，具体实现可参见方法实施例，在此不再赘述。

所属领域的技术人员可以清楚地了解到，为描述的方便和简洁，上述描述的装置和/或终端设备的具体工作过程，可以参考前述方法实施例中的对应过程，在此不再赘述。

最后应说明的是：以上所述实施例，仅为本发明的具体实施方式，用以说明本发明的技术方案，而非对其限制，本发明的保护范围并不局限于此，尽管参照前述实施例对本发明进行了详细的说明，本领域的普通技术人员应当理解：任何熟悉本技术领域的技术人员在本发明揭露的技术范围内，其依然可以对前述实施例所记载的技术方案进行修改或可轻易想到变化，或者对其中部分技术特征进行等同替换；而这些修改、变化或者替换，并不使相应技术方案的本质脱离本发明实施例技术方案的精神和范围，都应涵盖在本发明的保护范围之内。因此，本发明的保护范围应所述以权利要求的保护范围为准。

Claims (12)

1.一种数据加载方法，其特征在于，所述方法包括：

对目标python文件进行编译，得到位于模块层的父函数，以及所述父函数的子函数，所述父函数中包括所述python文件中的固定量，且所述python文件中的固定量与各个所述子函数相对应；

如果接收到数据查询指令，从所述数据查询指令中提取关键字；

判断所述关键字对应的数据是否已加载至内存；

如果否，确定所述关键字对应的数据的固定量对应的子函数；

执行确定的子函数，通过所述确定的子函数确定所述关键字对应的数据的固定量在所述父函数中的存储位置；

从所述存储位置提取所述关键字对应的数据的固定量，根据提取的所述固定量，输出所述关键字对应的数据；

将所述关键字对应的数据加载至内存。

2.根据权利要求1所述的方法，其特征在于，确定所述关键字对应的数据的固定量对应的子函数的步骤，包括：

计算所述关键字的哈希值；

按照预设的规模值对所述哈希值进行取模，得到取模结果；

将所述取模结果对应的子函数，确定为所述关键字对应的数据的固定量对应的子函数。

3.根据权利要求1所述的方法，其特征在于，

所述执行确定的子函数，包括：

执行所述确定的子函数中与所述关键字对应数据的固定量相关的字节码，所述字节码的操作参数包括所述关键字对应的数据的固定量在所述父函数中的存储位置。

4.根据权利要求3所述的方法，其特征在于，所述固定量包括常数类型的固定量、字符串类型的固定量。

5.根据权利要求4所述的方法，其特征在于，所述执行所述确定的子函数中与所述关键字对应数据的固定量相关的字节码的步骤，包括：

如果所述固定量为常数类型的固定量，并且所述确定的子函数包含与所述常数类型的固定量相关联的字节码，从所述模块层中的父函数中，所述字节码的操作参数指示的对应位置获取所述常数类型的固定量；

所述根据提取的所述固定量，输出所述关键字对应的数据的步骤，包括：

通过所述字节码的操作指令，处理获取到的所述常数类型的固定量，得到所述关键字对应的数据。

6.根据权利要求5所述的方法，其特征在于，所述从所述模块层中的父函数中，所述字节码的操作参数指示的对应位置获取所述常数类型的固定量的步骤，包括：

通过预设的MAKE_FUNCTION字节码，从所述模块层中的父函数中，所述字节码的操作参数指示对应位置获取所述常数类型的固定量。

7.根据权利要求4所述的方法，其特征在于，所述执行所述确定的子函数中与所述关键字对应数据的固定量相关的字节码的步骤，包括：

如果所述固定量为字符串类型的固定量，并且所述确定的子函数包含与所述字符串类型的固定量相关联的字节码，判断所述确定的子函数中是否存在与所述字符串类型的固定量相关联的索引标识；

如果不存在，从所述模块层中的父函数中，所述字节码的操作参数指示的对应位置获取所述字符串类型的固定量；将所述字符串类型的固定量存储至内存中的字符串列表中；在所述确定的子函数中添加与所述字符串类型的固定量相关联的索引标识；

如果存在，从内存中的字符串列表中，所述索引标识对应的位置获取所述字符串类型的固定量。

8.根据权利要求1所述的方法，其特征在于，所述内存中预设有延迟加载器；

所述将所述关键字对应的数据加载至内存的步骤，包括：通过所述延迟加载器，将所述关键字对应的数据加载至所述延迟加载器的字典中。

9.根据权利要求1所述的方法，其特征在于，将所述关键字对应的数据加载至内存的步骤之后，所述方法还包括：从所述内存中释放执行后的所述子函数。

10.一种数据加载装置，其特征在于，所述装置包括：

文件编译模块，用于对目标python文件进行编译，得到位于模块层的父函数，以及所述父函数的子函数，所述父函数中包括所述python文件中的固定量，且所述python文件中的固定量与各个所述子函数相对应；

关键字提取模块，用于如果接收到数据查询指令，从所述数据查询指令中提取关键字；

第一判断模块，用于判断所述关键字对应的数据是否已加载至内存；

子函数确定模块，用于如果否，确定所述关键字对应的数据的固定量对应的子函数；

子函数执行模块，用于执行确定的子函数，通过所述确定的子函数确定所述关键字对应的数据的固定量在所述父函数中的存储位置；

数据输出模块，用于从所述存储位置提取所述关键字对应的数据的固定量，根据提取的所述固定量，输出所述关键字对应的数据；

数据加载模块，用于将所述关键字对应的数据加载至内存。

11.一种终端设备，其特征在于，包括处理器和存储器，所述存储器存储有能够被所述处理器执行的计算机可执行指令，所述处理器执行所述计算机可执行指令以实现权利要求1至9任一项所述的数据加载方法的步骤。

12.一种计算机可读存储介质，其特征在于，所述计算机可读存储介质存储有计算机可执行指令，所述计算机可执行指令在被处理器调用和执行时，所述计算机可执行指令促使处理器实现权利要求1至9任一项所述的数据加载方法的步骤。

Images