python django性能测试与优化指南 -pg电子游戏网站

0顶
0踩

原文
作者:iulian gulea
翻译:雁惊寒

 

摘要:本文通过一个简单的实例一步一步引导读者对其进行全方位的性能优化。以下是译文。

 

唐纳德·克努特(donald knuth)曾经说过:“不成熟的优化方案是万恶之源。”然而,任何一个承受高负载的成熟项目都不可避免地需要进行优化。在本文中,我想谈谈优化web项目代码的五种常用方法。虽然本文是以django为例,但其他框架和语言的优化原则也是类似的。通过使用这些优化方法,文中例程的查询响应时间从原来的77秒减少到了3.7秒。


 

本文用到的例程是从一个我曾经使用过的真实项目改编而来的,是性能优化技巧的典范。如果你想自己尝试着进行优化,可以在上获取优化前的初始代码,并跟着下文做相应的修改。我使用的是python 2,因为一些第三方软件包还不支持python 3。

 

示例代码介绍

 

这个web项目只是简单地跟踪每个地区的房产价格。因此,只有两种模型:

# houses/models.py
from utils.hash import hasher
class hashablemodel(models.model):
    """provide a hash property for models."""
    class meta:
        abstract = true
    @property
    def hash(self):
        return hasher.from_model(self)
class country(hashablemodel):
    """represent a country in which the house is positioned."""
    name = models.charfield(max_length=30)
    def __unicode__(self):
        return self.name
class house(hashablemodel):
    """represent a house with its characteristics."""
    # relations
    country = models.foreignkey(country, related_name='houses')
    # attributes
    address = models.charfield(max_length=255)
    sq_meters = models.positiveintegerfield()
    kitchen_sq_meters = models.positivesmallintegerfield()
    nr_bedrooms = models.positivesmallintegerfield()
    nr_bathrooms = models.positivesmallintegerfield()
    nr_floors = models.positivesmallintegerfield(default=1)
    year_built = models.positiveintegerfield(null=true, blank=true)
    house_color_outside = models.charfield(max_length=20)
    distance_to_nearest_kindergarten = models.positiveintegerfield(null=true, blank=true)
    distance_to_nearest_school = models.positiveintegerfield(null=true, blank=true)
    distance_to_nearest_hospital = models.positiveintegerfield(null=true, blank=true)
    has_cellar = models.booleanfield(default=false)
    has_pool = models.booleanfield(default=false)
    has_garage = models.booleanfield(default=false)
    price = models.positiveintegerfield()
    def __unicode__(self):
        return '{} {}'.format(self.country, self.address)

 

抽象类hashablemodel提供了一个继承自模型并包含hash属性的模型,这个属性包含了实例的主键和模型的内容类型。 这能够隐藏像实例id这样的敏感数据,而用散列进行代替。如果项目中有多个模型,而且需要在一个集中的地方对模型进行解码并要对不同类的不同模型实例进行处理时,这可能会非常有用。 请注意,对于本文的这个小项目,即使不用散列也照样可以处理,但使用散列有助于展示一些优化技巧。

 

这是hasher类:

# utils/hash.py
import basehash
class hasher(object):
    @classmethod
    def from_model(cls, obj, klass=none):
        if obj.pk is none:
            return none
        return cls.make_hash(obj.pk, klass if klass is not none else obj)
    @classmethod
    def make_hash(cls, object_pk, klass):
        base36 = basehash.base36()
        content_type = contenttype.objects.get_for_model(klass, for_concrete_model=false)
        return base36.hash('%(contenttype_pk)03d%(object_pk)06d' % {
            'contenttype_pk': content_type.pk,
            'object_pk': object_pk
        })
    @classmethod
    def parse_hash(cls, obj_hash):
        base36 = basehash.base36()
        unhashed = '	d' % base36.unhash(obj_hash)
        contenttype_pk = int(unhashed[:-6])
        object_pk = int(unhashed[-6:])
        return contenttype_pk, object_pk
    @classmethod
    def to_object_pk(cls, obj_hash):    
        return cls.parse_hash(obj_hash)[1]

 

由于我们想通过api来提供这些数据,所以我们安装了django rest框架并定义以下序列化器和视图:

# houses/serializers.py
class houseserializer(serializers.modelserializer):
    """serialize a `houses.house` instance."""
    id = serializers.readonlyfield(source="hash")
    country = serializers.readonlyfield(source="country.hash")
    class meta:
        model = house
        fields = (
            'id',
            'address',
            'country',
            'sq_meters',
            'price'
        )

 

# houses/views.py
class houselistapiview(listapiview):
    model = house
    serializer_class = houseserializer
    country = none
    def get_queryset(self):
        country = get_object_or_404(country, pk=self.country)
        queryset = self.model.objects.filter(country=country)
        return queryset
    def list(self, request, *args, **kwargs):
        # skipping validation code for brevity
        country = self.request.get.get("country")
        self.country = hasher.to_object_pk(country)
        queryset = self.get_queryset()
        serializer = self.serializer_class(queryset, many=true)
        return response(serializer.data)

 

现在,我们将用一些数据来填充数据库(使用factory-boy生成10万个房屋的实例:一个地区5万个,另一个4万个,第三个1万个),并准备测试应用程序的性能。

 

性能优化其实就是测量

 

在一个项目中我们需要测量下面这几个方面:

 

  • 执行时间
  • 代码的行数
  • 函数调用次数
  • 分配的内存
  • 其他

但是,并不是所有这些都要用来度量项目的执行情况。一般来说,有两个指标比较重要:执行多长时间、需要多少内存。

 

在web项目中,响应时间(服务器接收由某个用户的操作产生的请求,处理该请求并返回结果所需的总的时间)通常是最重要的指标,因为过长的响应时间会让用户厌倦等待,并切换到浏览器中的另一个选项卡页面。

 

在编程中,分析项目的性能被称为。为了分析api的性能,我们将使用包。在安装完这个包,并调用/api/v1/houses/?country=5t22ri后,可以得到如下的结果:

200 get 
/api/v1/houses/
77292ms overall
15854ms on queries
50004 queries

 

 整体响应时间为77秒,其中16秒用于查询数据库,总共有5万次查询。这几个数字很大,提升空间也有很大,所以,我们开始吧。

 

1. 优化数据库查询

 

性能优化最常见的技巧之一是对数据库查询进行优化,本案例也不例外。同时,还可以对查询做多次优化来减小响应时间。

 

1.1 一次提供所有数据

 

仔细看一下这5万次查询查的是什么:都是对houses_country表的查询:

200 get 
/api/v1/houses/
77292ms overall
15854ms on queries
50004 queries

 

时间戳 表名 联合 执行时间(毫秒)
0:01 :15.874374 “houses_country” 0 0.176
0:01 :15.873304 “houses_country” 0 0.218
0:01 :15.872225 “houses_country” 0 0.218
0:01 :15.871155 “houses_country” 0 0.198
0:01 :15.870099 “houses_country” 0 0.173
0:01 :15.869050 “houses_country” 0 0.197
0:01 :15.867877 “houses_country” 0 0.221
0:01 :15.866807 “houses_country” 0 0.203
0:01 :15.865646 “houses_country” 0 0.211
0:01 :15.864562 “houses_country” 0 0.209
0:01 :15.863511 “houses_country” 0 0.181
0:01 :15.862435 “houses_country” 0 0.228
0:01 :15.861413 “houses_country” 0 0.174

 

这个问题的根源是,django中的查询是惰性的。这意味着在你真正需要获取数据之前它不会访问数据库。同时,它只获取你指定的数据,如果需要其他附加数据,则要另外发出请求。

 

这正是本例程所遇到的情况。当通过house.objects.filter(country=country)来获得查询集时,django将获取特定地区的所有房屋。但是,在序列化一个house实例时,houseserializer需要房子的country实例来计算序列化器的country字段。由于地区数据不在查询集中,所以django需要提出额外的请求来获取这些数据。对于查询集中的每一个房子都是如此,因此,总共是五万次。

 

当然,pg电子游戏网站的解决方案非常简单。为了提取所有需要的序列化数据,你可以在查询集上使用。因此,get_queryset函数将如下所示:

def get_queryset(self):
    country = get_object_or_404(country, pk=self.country)
    queryset = self.model.objects.filter(country=country).select_related('country')
    return queryset

 

我们来看看这对性能有何影响:

200 get
/api/v1/houses/
35979ms overall
102ms on queries
4 queries

 

总体响应时间降至36秒,在数据库中花费的时间约为100ms,只有4个查询!这是个好消息,但我们可以做得更多。

 

1.2 仅提供相关的数据

 

默认情况下,django会从数据库中提取所有字段。但是,当表有很多列很多行的时候,告诉django提取哪些特定的字段就非常有意义了,这样就不会花时间去获取根本用不到的信息。在本案例中,我们只需要5个字段来进行序列化,虽然表中有17个字段。明确指定从数据库中提取哪些字段是很有意义的,可以进一步缩短响应时间。

 

django可以使用和这两个查询方法来实现这一点。第一个用于指定哪些字段不要加载,第二个用于指定只加载哪些字段。

def get_queryset(self):
    country = get_object_or_404(country, pk=self.country)
    queryset = self.model.objects.filter(country=country)\
        .select_related('country')\
        .only('id', 'address', 'country', 'sq_meters', 'price')
    return queryset

 

这减少了一半的查询时间,非常不错。总体时间也略有下降,但还有更多提升空间。

200 get
/api/v1/houses/
33111ms overall
52ms on queries
4 queries

 

2. 代码优化

 

你不能无限制地优化数据库查询,并且上面的结果也证明了这一点。即使把查询时间减少到0,我们仍然会面对需要等待半分钟才能得到应答这个现实。现在是时候转移到另一个优化级别上来了,那就是:业务逻辑

 

2.1 简化代码

 

有时,第三方软件包对于简单的任务来说有着太大的开销。本文例程中返回的序列化的房子实例正说明了这一点。

 

django rest框架非常棒,包含了很多有用的功能。但是,现在的主要目标是缩短响应时间,所以该框架是优化的候选对象,尤其是我们要使用的序列化对象这个功能非常的简单。

 

为此,我们来编写一个自定义的序列化器。为了方便起见,我们将用一个静态方法来完成这项工作。

# houses/serializers.py
class houseplainserializer(object):
    """
    serializes a house queryset consisting of dicts with
    the following keys: 'id', 'address', 'country',
    'sq_meters', 'price'.
    """
    @staticmethod
    def serialize_data(queryset):
        """
        return a list of hashed objects from the given queryset.
        """
        return [
            {
                'id': hasher.from_pk_and_class(entry['id'], house),
                'address': entry['address'],
                'country': hasher.from_pk_and_class(entry['country'], country),
                'sq_meters': entry['sq_meters'],
                'price': entry['price']
            } for entry in queryset
        ]
# houses/views.py
class houselistapiview(listapiview):
    model = house
    serializer_class = houseserializer
    plain_serializer_class = houseplainserializer  # <-- added custom serializer
    country = none
    def get_queryset(self):
        country = get_object_or_404(country, pk=self.country)
        queryset = self.model.objects.filter(country=country)
        return queryset
    def list(self, request, *args, **kwargs):
        # skipping validation code for brevity
        country = self.request.get.get("country")
        self.country = hasher.to_object_pk(country)
        queryset = self.get_queryset()
        data = self.plain_serializer_class.serialize_data(queryset)  # <-- serialize
        return response(data)

 

200 get
/api/v1/houses/
17312ms overall
38ms on queries
4 queries

 

现在看起来好多了,由于没有使用drf序列化代码,所以响应时间几乎减少了一半。

 

另外还有一个结果:在请求/响应周期内完成的总的函数调用次数从15,859,427次(上面1.2节的请求次数)减少到了9,257,469次。这意味着大约有三分之一的函数调用都是由django rest framework产生的。

 

2.2 更新或替代第三方软件包

 

上述几个优化技巧是最常见的,无需深入地分析和思考就可以做到。然而,17秒的响应时间仍然感觉很长。要减少这个时间,需要更深入地了解代码,分析底层发生了什么。换句话说,需要分析一下代码。

 

你可以自己使用python内置的分析器来进行分析,也可以使用一些第三方软件包。由于我们已经使用了silk,它可以分析代码并生成一个二进制的分析文件,因此,我们可以做进一步的可视化分析。有好几个可视化软件包可以将二进制文件转换为一些友好的可视化视图。本文将使用。

 

这是上文一个请求的二进制分析文件的可视化图表:


从上到下是调用堆栈,显示了文件名、函数名及其行号,以及该方法花费的时间。可以很容易地看出,时间大部分都用在计算散列上(紫罗兰色的__init__.pyprimes.py矩形)。

 

目前,这是代码的主要性能瓶颈,但同时,这不是我们自己写的代码,而是用的第三方包。

 

在这种情况下,我们可以做的事情将非常有限:

 

  • 检查包的最新版本(希望能有更好的性能)。
  • 寻找另一个能够满足我们需求的软件包。
  • 我们自己写代码,并且性能优于目前使用的软件包。

幸运的是,我们找到了一个更新版本的basehash包。原代码使用的是v.2.1.0,而新的是v.3.0.4。

 

当查看v.3的发行说明时,这一句话看起来令人充满希望:

“使用素数算法进行大规模的优化。”

 让我们来看一下!

pip install -u basehash gmpy2

 

200 get
/api/v1/houses/
7738ms overall
59ms on queries
4 queries

 

 响应时间从17秒缩短到了8秒以内。太棒了!但还有一件事我们应该来看看。

 

2.3 重构代码

 

到目前为止,我们已经改进了查询、用自己特定的函数取代了第三方复杂而又泛型的代码、更新了第三方包,但是我们还是保留了原有的代码。但有时,对现有代码进行小规模的重构可能会带来意想不到的结果。但是,为此我们需要再次分析运行结果。


 仔细看一下,你可以看到散列仍然是一个问题(毫不奇怪,这是我们对数据做的唯一的事情),虽然我们确实朝这个方向改进了,但这个绿色的矩形表示__init__.py花了2.14秒的时间,同时伴随着灰色的__init__.py:54(hash)。这意味着初始化工作需要很长的时间。

 

我们来看看basehash包的源代码。

# basehash/__init__.py
# initialization of `base36` class initializes the parent, `base` class.
class base36(base):
    def __init__(self, length=hash_length, generator=generator):
        super(base36, self).__init__(base36, length, generator)
class base(object):
    def __init__(self, alphabet, length=hash_length, generator=generator):
        if len(set(alphabet)) != len(alphabet):
            raise valueerror('supplied alphabet cannot contain duplicates.')
        self.alphabet = tuple(alphabet)
        self.base = len(alphabet)
        self.length = length
        self.generator = generator
        self.maximum = self.base ** self.length - 1
        self.prime = next_prime(int((self.maximum   1) * self.generator))  # `next_prime` call on each initialized instance

 

 正如你所看到的,一个base实例的初始化需要调用next_prime函数,这是太重了,我们可以在上面的可视化图表中看到左下角的矩形。

 

我们再来看看hash类:

class hasher(object):
    @classmethod
    def from_model(cls, obj, klass=none):
        if obj.pk is none:
            return none
        return cls.make_hash(obj.pk, klass if klass is not none else obj)
    @classmethod
    def make_hash(cls, object_pk, klass):
        base36 = basehash.base36()  # <-- initializing on each method call
        content_type = contenttype.objects.get_for_model(klass, for_concrete_model=false)
        return base36.hash('%(contenttype_pk)03d%(object_pk)06d' % {
            'contenttype_pk': content_type.pk,
            'object_pk': object_pk
        })
    @classmethod
    def parse_hash(cls, obj_hash):
        base36 = basehash.base36()  # <-- initializing on each method call
        unhashed = '	d' % base36.unhash(obj_hash)
        contenttype_pk = int(unhashed[:-6])
        object_pk = int(unhashed[-6:])
        return contenttype_pk, object_pk
    @classmethod
    def to_object_pk(cls, obj_hash):    
        return cls.parse_hash(obj_hash)[1]

 

 正如你所看到的,我已经标记了这两个方法初始化base36实例的方法,这并不是真正需要的。

由于散列是一个确定性的过程,这意味着对于一个给定的输入值,它必须始终生成相同的散列值,因此,我们可以把它作为类的一个属性。让我们来看看它将如何执行:

class hasher(object):
    base36 = basehash.base36()  # <-- initialize hasher only once
    @classmethod
    def from_model(cls, obj, klass=none):
        if obj.pk is none:
            return none
        return cls.make_hash(obj.pk, klass if klass is not none else obj)
    @classmethod
    def make_hash(cls, object_pk, klass):
        content_type = contenttype.objects.get_for_model(klass, for_concrete_model=false)
        return cls.base36.hash('%(contenttype_pk)03d%(object_pk)06d' % {
            'contenttype_pk': content_type.pk,
            'object_pk': object_pk
        })
    @classmethod
    def parse_hash(cls, obj_hash):
        unhashed = '	d' % cls.base36.unhash(obj_hash)
        contenttype_pk = int(unhashed[:-6])
        object_pk = int(unhashed[-6:])
        return contenttype_pk, object_pk
    @classmethod
    def to_object_pk(cls, obj_hash):    
        return cls.parse_hash(obj_hash)[1]

 

**200 get**
  /api/v1/houses/
3766ms overall
38ms on queries
4 queries

 

 最后的结果是在4秒钟之内,比我们一开始的时间要小得多。对响应时间的进一步优化可以通过使用缓存来实现,但是我不会在这篇文章中介绍这个。

 

结论

 

性能优化是一个分析和发现的过程。 没有哪个硬性规定能适用于所有情况,因为每个项目都有自己的流程和瓶颈。 然而,你应该做的第一件事是分析代码。 如果在这样一个简短的例子中,我可以将响应时间从77秒缩短到3.7秒,那么对于一个庞大的项目来说,就会有更大的优化潜力。

0
0
评论 共 0 条 请登录后发表评论

发表评论

您还没有登录,请您登录后再发表评论

相关推荐

  • 文章目录python、c 与文言文、白话文鱼和熊掌兼而得之创建一门新的语言,这门语言能够写起来像python,跑起来像c julianim拼命提升高级语言python的运行效率将python转化成c、c 代码进行优化cythonnuitkapythran...

  • 虽然本文是以django为例,但其他框架和语言的优化原则也是类似的。通过使用这些优化方法,文中例程的查询响应时间从原来的77秒减少到了3.7秒。 本文用到的例程是从一个我曾经使用过的真实项目改编而来的,是性能优化...

  • 虽然本文是以django为例,但其他框架和语言的优化原则也是类似的。通过使用这些优化方法,文中例程的查询响应时间从原来的77秒减少到了3.7秒。?本文用到的例程是从一个我曾经使用过的真实项目改编而来的,是...

  • 唐纳德·克努特(donald knuth)曾经说过:“不成熟的优化方案是万恶之源。”然而,任何一个承受高负载的成熟项目都不可避免地需要进行优化。在本文中,我想谈谈优化web项目代码的五种常用方法。虽然本文是以d

  • django官方文档:https://docs.djangoproject.com/en/3.2/django官方文档:https://docs.djangoproject.com/en/3.2/django官方文档:https://docs.djangoproject.com/en/3.2/django中文文档:https://www.django.cn/

  • 性能优化: 提供关于python代码性能优化的实践指南,包括算法优化、内存管理和代码优化技巧。 网络编程和web开发: 涉及python网络编程的高级主题,以及web开发中的相关技术,如使用框架(例如django或flask)构建...

  • 跨站点脚本(xss)保护 xss攻击使用户可以将客户端脚本注入其他用户的浏览器中...使用django模板可以保护您免受大多数xss攻击。但是,重要的是要了解其提供的保护及其限制。 django模板会转义特定字符,这对于html来.

  • 开发工程师the5fire教你学会如何使用流行的python,web框架django介绍python web框架django在企业中的应用的书籍,从零开发到部署完整案例,django企业开发实战高效python web框架指南电子版是开发工程师the5fire...

  • autocomplete-light优化性能222 10.2.1创造1万个分类223 10.2.2django-autocomplete-light介绍224 10.2.3引入插件224 10.2.4总结226 10.2.5参考资料226 10.3使用django-ckeditor开发富文本编辑器226 10.3.1基础配置...

  • python的web框架有django、tornado、flask 等多种,django是重量级选手中最有代表性的一位,它的优势为:大而全,框架本身集成了orm、模型绑定、模板引擎、缓存、session等诸多功能。许多成功的网站和app都基于...

  • 本文全面介绍了flask、django和fastapi这三个主流的python web框架,以及与之相关的数据库、orm库、安全性与认证、前端框架与交互、测试与调试工具。每个部分都包含详细的介绍和实例代码,帮助读者理解框架的核心...

  • python库是一组预先编写的代码模块,旨在帮助开发者实现特定的编程任务,无需从零开始编写代码。这些库可以包括各种功能,如数学运算、文件操作、数据分析和网络编程等。python社区提供了大量的第三方库,如numpy、pandas和requests,极大地丰富了python的应用领域,从数据科学到web开发。python库的丰富性是python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径,而且为经验丰富的开发者提供了强大的工具,以高效率、高质量地完成复杂任务。例如,matplotlib和seaborn库在数据可视化领域内非常受欢迎,它们提供了广泛的工具和技术,可以创建高度定制化的图表和图形,帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。

  • stm32单片机fpga毕设电路原理论文报告基于ide硬盘的数字图像存储技术研究本资源系百度网盘分享地址

  • 适合rust入门。深入浅出,事无巨细,远胜市面上所有入门书。而且是免费的

  • vb语言vb房屋租凭管理系统毕业设计(源代码 系统)本资源系百度网盘分享地址

  • 这个示例代码,我们实现了一个用 c 语言判断一个数是否为素数的函数,并通过 main() 函数来测试这个函数。整个过程简单明了,代码结构清晰,易于理解和修改。这个示例展示了 c 语言中函数的定义和调用,以及条件判断和循环等基本语法的使用。

  • 层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例层次化网络设计案例

  • 1、嵌入式物联网单片机项目开发实战,每个例程都经过实战检验,简单好用。 2、代码同系列芯片理论是通用的。其他单片机型号请自行更改。 3、软件下载时,请注意下载方式以及对应的下载工具。 4、技术v:wulianjishu666; 5、如果接入其他传感器,请查看发布的其他资料。 6、单片机与模块的接线,在代码当中均有定义,请自行对照。

  • 四脚板凳u型焊接端子冲压成形机sw18可编辑_零件图_机械工程图_机械三维3d建模图打包下载.zip

  • python库是一组预先编写的代码模块,旨在帮助开发者实现特定的编程任务,无需从零开始编写代码。这些库可以包括各种功能,如数学运算、文件操作、数据分析和网络编程等。python社区提供了大量的第三方库,如numpy、pandas和requests,极大地丰富了python的应用领域,从数据科学到web开发。python库的丰富性是python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径,而且为经验丰富的开发者提供了强大的工具,以高效率、高质量地完成复杂任务。例如,matplotlib和seaborn库在数据可视化领域内非常受欢迎,它们提供了广泛的工具和技术,可以创建高度定制化的图表和图形,帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。

global site tag (gtag.js) - google analytics
网站地图