精华内容
下载资源
问答
  • 昨天学到一招,不用像之前一样想看程序执行慢的时候到底慢在哪里就到处写"...了,有一个profile模块可以查看执行过程中各个调用的耗时。 用法是: import profile …… profile.run('exe_str') ...

    昨天学到一招,不用像之前一样想看程序执行慢的时候到底慢在哪里就到处写"start_time = time.time() end_time =  time.time()  use_time = end_time - start_time"了,有一个profile模块可以查看执行过程中各个调用的耗时。

    用法是:

    import profile

    ……

    profile.run('exe_str')

    这里的exe_str代表的就是把我们要执行的代码以字符串形式给profile,如果代码里有单引号要么转义掉,要么字符串外面换用双引号。

    比如:

    # -*- coding:utf-8 -*-
    import profile
    import time
    
    def tell_time():
        for i in range(10):
            print time.time()
            
    profile.run('tell_time()')

    然后除了你代码里输出的东西以外还会有一堆这种东西

             15 function calls in 0.001 seconds
    
       Ordered by: standard name
    
       ncalls  tottime  percall  cumtime  percall filename:lineno(function)
            1    0.000    0.000    0.000    0.000 :0(range)
            1    0.001    0.001    0.001    0.001 :0(setprofile)
           10    0.000    0.000    0.000    0.000 :0(time)
            1    0.000    0.000    0.000    0.000 <string>:1(<module>)
            0    0.000             0.000          profile:0(profiler)
            1    0.000    0.000    0.001    0.001 profile:0(tell_time())
            1    0.000    0.000    0.000    0.000 say_hello_profile.py:5(tell_time)

    这就是profile返回的程序各个部分的性能情况,很容易找到程序的性能瓶颈。

    结果里各项的意义:

     

    ncalls函数的被调用次数
    tottime函数总计运行时间,除去函数中调用的函数运行时间
    percall函数运行一次的平均时间,等于tottime/ncalls
    cumtime函数总计运行时间,含调用的函数运行时间
    percall函数运行一次的平均时间,等于cumtime/ncalls

     

     

     

     

     

    展开全文
  • python profile模块

    2013-12-13 14:40:58
    profile测试: import profile import pstats profile.runctx("test_method()",globals(),locals(),"test.log") p=pstats.Stats("test.log") p.sort_stats("cumulative").print_stats(20)

    profile测试:

    import profile
    import pstats
    profile.runctx("test_method()",globals(),locals(),"test.log")
    p=pstats.Stats("test.log")
    p.sort_stats("cumulative").print_stats(20)


    Unofficial Windows Binaries for Python Extension Packages:

    address:http://www.lfd.uci.edu/~gohlke/pythonlibs/

    
    展开全文
  • line_profiler , 我经常使用它来分析我的脚本有多快,以及每行代码执行的频率: 为了使用它,你可以通过使用 pip 来安装它: pip install line_profiler 安装完成后,你将获得一个新模块称为 line_profiler 和 ...

    内存占用分析

    kernprof, cprofile

    运行时间分析

    kernprof ,cprofile

    line_profiler和memory_profiler的IPython快捷方式

    Python高性能编程

    《Python高性能编程》——2.8 用line_profiler进行逐行分析
    本节书摘来自异步社区《Python高性能编程》一书中的第2章,第2.8节,作者[美] 戈雷利克 (Micha Gorelick),胡世杰,徐旭彬 译,更多章节内容可以访问云栖社区“异步社区”公众号查看。

    2.8 用line_profiler进行逐行分析
    根据Ian的观点,Robert Kern的line_profiler是调查Python的CPU密集型性能问题最强大的工具。
    它可以对函数进行逐行分析,你应该先用cProfile找到需要分析的函数,然后用line_profiler对函数进行分析

    当你修改你的代码时,值得打印出这个工具的输出以及代码的版本,这样你就拥有一个代码变化(无论有没有用)的记录,让你可以随时查阅。当你在进行逐行改变时,不要依赖你的记忆。

    输入命令pip install line_profiler来安装line_profiler。

    用修饰器(@profile)标记选中的函数。用kernprof.py脚本运行你的代码,被选函数每一行花费的CPU时间以及其他信息就会被记录下来。

    Python 性能分析入门指南

    虽然并非你编写的每个 Python 程序都要求一个严格的性能分析,但是让人放心的是,当问题发生的时候,Python 生态圈有各种各样的工具可以处理这类问题。

    分析程序的性能可以归结为回答四个基本问题:

    正运行的多快
    速度瓶颈在哪里
    内存使用率是多少
    内存泄露在哪里
    下面,我们将用一些神奇的工具深入到这些问题的答案中去。

    用 time 粗粒度的计算时间

    让我们开始通过使用一个快速和粗暴的方法计算我们的代码:传统的 unix time 工具。

    $ time python yourprogram.py
    real 0m1.028s
    user 0m0.001s
    sys 0m0.003s
    三个输出测量值之间的详细意义在这里 stackoverflow article,但简介在这:

    real — 指的是实际耗时
    user — 指的是内核之外的 CPU 耗时
    sys — 指的是花费在内核特定函数的 CPU 耗时
    你会有你的应用程序用完了多少 CPU 周期的即视感,不管系统上其他运行的程序添加的系统和用户时间。

    如果 sys 和 user 时间之和小于 real 时间,然后你可以猜测到大多数程序的性能问题最有可能与 IO wait 相关。

    用 timing context 管理器细粒度的计算时间

    我们下一步的技术包括直接嵌入代码来获取细粒度的计时信息。下面是我进行时间测量的代码的一个小片段

    timer.py

    import time

    class Timer(object):
    def init(self, verbose=False):
    self.verbose = verbose

    def __enter__(self):
        self.start = time.time()
        return self
    
    def __exit__(self, *args):
        self.end = time.time()
        self.secs = self.end - self.start
        self.msecs = self.secs * 1000  # millisecs
        if self.verbose:
            print 'elapsed time: %f ms' % self.msecs
    

    为了使用它,使用 Python 的 with 关键字和 Timer 上下文管理器来包装你想计算的代码。当您的代码块开始执行,它将照顾启动计时器,当你的代码块结束的时候,它将停止计时器。

    这个代码片段示例:

    from timer import Timer
    from redis import Redis
    rdb = Redis()

    with Timer() as t:
    rdb.lpush(“foo”, “bar”)
    print “=> elasped lpush: %s s” % t.secs

    with Timer() as t:
    rdb.lpop(“foo”)
    print “=> elasped lpop: %s s” % t.secs
    为了看看我的程序的性能随着时间的演化的趋势,我常常记录这些定时器的输出到一个文件中。

    使用 profiler 逐行计时和分析执行的频率

    罗伯特·克恩有一个不错的项目称为 line_profiler , 我经常使用它来分析我的脚本有多快,以及每行代码执行的频率:

    为了使用它,你可以通过使用 pip 来安装它:

    pip install line_profiler
    安装完成后,你将获得一个新模块称为 line_profiler 和 kernprof.py 可执行脚本。

    为了使用这个工具,首先在你想测量的函数上设置 @profile 修饰符。不用担心,为了这个修饰符,你不需要引入任何东西。 kernprof.py 脚本会在运行时自动注入你的脚本。

    primes.py

    @profile
    def primes(n):
    if n==2:
    return [2]
    elif n<2:
    return []
    s=range(3,n+1,2)
    mroot = n ** 0.5
    half=(n+1)/2-1
    i=0
    m=3
    while m <= mroot:
    if s[i]:
    j=(mm-3)/2
    s[j]=0
    while j<half:
    s[j]=0
    j+=m
    i=i+1
    m=2
    i+3
    return [2]+[x for x in s if x]
    primes(100)
    一旦你得到了你的设置了修饰符 @profile 的代码,使用 kernprof.py 运行这个脚本。

    kernprof.py -l -v fib.py
    -l 选项告诉 kernprof 把修饰符 @profile 注入你的脚本, -v 选项告诉 kernprof 一旦你的脚本完成后,展示计时信息。这是一个以上脚本的类似输出:

    Wrote profile results to primes.py.lprof
    Timer unit: 1e-06 s

    File: primes.py
    Function: primes at line 2
    Total time: 0.00019 s

    Line # Hits Time Per Hit % Time Line Contents

     2                                           @profile
     3                                           def primes(n): 
     4         1            2      2.0      1.1      if n==2:
     5                                                   return [2]
     6         1            1      1.0      0.5      elif n<2:
     7                                                   return []
     8         1            4      4.0      2.1      s=range(3,n+1,2)
     9         1           10     10.0      5.3      mroot = n ** 0.5
    10         1            2      2.0      1.1      half=(n+1)/2-1
    11         1            1      1.0      0.5      i=0
    12         1            1      1.0      0.5      m=3
    13         5            7      1.4      3.7      while m <= mroot:
    14         4            4      1.0      2.1          if s[i]:
    15         3            4      1.3      2.1              j=(m*m-3)/2
    16         3            4      1.3      2.1              s[j]=0
    17        31           31      1.0     16.3              while j<half:
    18        28           28      1.0     14.7                  s[j]=0
    19        28           29      1.0     15.3                  j+=m
    20         4            4      1.0      2.1          i=i+1
    21         4            4      1.0      2.1          m=2*i+3
    22        50           54      1.1     28.4      return [2]+[x for x
    

    寻找 hits 值比较高的行或是一个高时间间隔。这些地方有最大的优化改进空间。

    它使用了多少内存?

    现在我们掌握了很好我们代码的计时信息,让我们继续找出我们的程序使用了多少内存。我们真是非常幸运, Fabian Pedregosa 仿照 Robert Kern 的 line_profiler 实现了一个很好的内存分析器 [memory profiler][5]。

    首先通过 pip 安装它:

    $ pip install -U memory_profiler
    $ pip install psutil
    在这里建议安装 psutil 是因为该包能提升 memory_profiler 的性能。

    想 line_profiler 一样, memory_profiler 要求在你设置 @profile 来修饰你的函数:

    @profile
    def primes(n):


    运行如下命令来显示你的函数使用了多少内存:

    $ python -m memory_profiler primes.py
    一旦你的程序退出,你应该可以看到这样的输出:

    Filename: primes.py

    Line # Mem usage Increment Line Contents

     2                           @profile
     3    7.9219 MB  0.0000 MB   def primes(n): 
     4    7.9219 MB  0.0000 MB       if n==2:
     5                                   return [2]
     6    7.9219 MB  0.0000 MB       elif n<2:
     7                                   return []
     8    7.9219 MB  0.0000 MB       s=range(3,n+1,2)
     9    7.9258 MB  0.0039 MB       mroot = n ** 0.5
    10    7.9258 MB  0.0000 MB       half=(n+1)/2-1
    11    7.9258 MB  0.0000 MB       i=0
    12    7.9258 MB  0.0000 MB       m=3
    13    7.9297 MB  0.0039 MB       while m <= mroot:
    14    7.9297 MB  0.0000 MB           if s[i]:
    15    7.9297 MB  0.0000 MB               j=(m*m-3)/2
    16    7.9258 MB -0.0039 MB               s[j]=0
    17    7.9297 MB  0.0039 MB               while j<half:
    18    7.9297 MB  0.0000 MB                   s[j]=0
    19    7.9297 MB  0.0000 MB                   j+=m
    20    7.9297 MB  0.0000 MB           i=i+1
    21    7.9297 MB  0.0000 MB           m=2*i+3
    22    7.9297 MB  0.0000 MB       return [2]+[x for x in s if x]
    
    line_profiler 和 memory_profiler 的 IPython 快捷命令

    line_profiler 和 memory_profiler 一个鲜为人知的特性就是在 IPython 上都有快捷命令。你所能做的就是在 IPython 上键入以下命令:

    %load_ext memory_profiler
    %load_ext line_profiler
    这样做了以后,你就可以使用魔法命令 %lprun 和 %mprun 了,它们表现的像它们命令行的副本,最主要的不同就是你不需要给你需要分析的函数设置 @profile 修饰符。直接在你的 IPython 会话上继续分析吧。

    In [1]: from primes import primes
    In [2]: %mprun -f primes primes(1000)
    In [3]: %lprun -f primes primes(1000)
    这可以节省你大量的时间和精力,因为使用这些分析命令,你不需要修改你的源代码。

    哪里内存溢出了?

    cPython的解释器使用引用计数来作为它跟踪内存的主要方法。这意味着每个对象持有一个计数器,当增加某个对象的引用存储的时候,计数器就会增加,当一个引用被删除的时候,计数器就是减少。当计数器达到0, cPython 解释器就知道该对象不再使用,因此解释器将删除这个对象,并且释放该对象持有的内存。

    内存泄漏往往发生在即使该对象不再使用的时候,你的程序还持有对该对象的引用。

    最快速发现内存泄漏的方式就是使用一个由 Marius Gedminas 编写的非常好的称为 [objgraph][6] 的工具。
    这个工具可以让你看到在内存中对象的数量,也定位在代码中所有不同的地方,对这些对象的引用。

    开始,我们首先安装 objgraph

    pip install objgraph
    一旦你安装了这个工具,在你的代码中插入一个调用调试器的声明。

    import pdb; pdb.set_trace()

    哪个对象最常见

    在运行时,你可以检查在运行在你的程序中的前20名最普遍的对象

    pdb) import objgraph
    (pdb) objgraph.show_most_common_types()

    MyBigFatObject 20000
    tuple 16938
    function 4310
    dict 2790
    wrapper_descriptor 1181
    builtin_function_or_method 934
    weakref 764
    list 634
    method_descriptor 507
    getset_descriptor 451
    type 439

    哪个对象被增加或是删除了?

    我们能在两个时间点之间看到哪些对象被增加或是删除了。

    (pdb) import objgraph
    (pdb) objgraph.show_growth()
    .
    .
    .
    (pdb) objgraph.show_growth() # this only shows objects that has been added or deleted since last show_growth() call

    traceback 4 +2
    KeyboardInterrupt 1 +1
    frame 24 +1
    list 667 +1
    tuple 16969 +1

    这个泄漏对象的引用是什么?

    继续下去,我们还可以看到任何给定对象的引用在什么地方。让我们以下面这个简单的程序举个例子。

    x = [1]
    y = [x, [x], {“a”:x}]
    import pdb; pdb.set_trace()
    为了看到持有变量 X 的引用是什么,运行 objgraph.show_backref() 函数:

    (pdb) import objgraph
    (pdb) objgraph.show_backref([x], filename="/tmp/backrefs.png")
    该命令的输出是一个 PNG 图片,被存储在 /tmp/backrefs.png,它应该看起来像这样:

    backrefs (1)

    盒子底部有红色字体就是我们感兴趣的对象,我们可以看到它被符号 x 引用了一次,被列表 y 引用了三次。如果 x 这个对象引起了内存泄漏,我们可以使用这种方法来追踪它的所有引用,以便看到为什么它没有被自动被收回。

    回顾一遍,objgraph 允许我们:

    显示占用 Python 程序内存的前 N 个对象
    显示在一段时期内哪些对象被增加了,哪些对象被删除了
    显示我们脚本中获得的所有引用

    展开全文
  • 主要介绍了Django使用Profile扩展User模块方式,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • Django使用Profile扩展User模块

    千次阅读 2016-02-02 09:06:32
    Django使用Profile扩展User模块首先创建Profile应用python manage.py startapp profilesprofiles/models.py# -*- coding: utf-8 -*- from django.db import models from django.contrib.auth.models import User ...

    Django使用Profile扩展User模块

    首先创建Profile应用

    python manage.py startapp profiles

    profiles/models.py

    # -*- coding: utf-8 -*-
    from django.db import models
    from django.contrib.auth.models import User
    from django.db.models.signals import post_save
    
    
    class UserProfile(models.Model):
        user = models.OneToOneField(User)
        nickname = models.CharField(max_length=16, default='', blank=True)
        sex = models.IntegerField(default=0)
        phone = models.CharField(max_length=16, default='', blank=True)
    
        def __str__(self):
            return self.nickname
    
        def __unicode__(self):
            return self.nickname
    
    
    def create_user_profile(sender, instance, created, **kwargs):
        if created:
            profile = UserProfile()
            profile.user = instance
            profile.save()
    
    post_save.connect(create_user_profile, sender=User)

    profiles/admin.py

    # -*- coding: utf-8 -*-
    from django.contrib import admin
    from django.contrib.auth.models import User
    from django.contrib.auth.admin import UserAdmin
    from .models import UserProfile
    
    
    class ProfileInline(admin.StackedInline):
        model = UserProfile
        max_num = 1
        can_delete = False
    
    
    class UserProfileAdmin(UserAdmin):
        inlines = [ProfileInline, ]
    
    
    admin.site.unregister(User)
    admin.site.register(User, UserProfileAdmin)

    settings.py

    添加

    AUTH_PROFILE_MODULE = 'profiles.UserProfile'

    测试

    $ python manage.py syncdb
    $ python manage.py shell
    >>> from django.contrib.auth.models import User
    >>> user = User()
    >>> user.username='testuser'
    >>> user.save()
    >>> User.objects.all()[0].userprofile

    转载请以链接形式标明本文地址
    本文地址:http://blog.csdn.net/kongxx/article/details/50621745

    展开全文
  • mobileconfig_profile 模块提供了一种新的资源类型,用于在 Mac OS X 上安装和删除 mobileconfig 配置文件。这些配置文件允许您强制执行策略并以其他方式配置 OS X。 您可以通过以下几种方式制作此类配置文件: ...
  • 轮廓 该模块将用户配置文件和动态数据添加到Zikula用户帐户。 需要Zikula Core 3.0.0+
  • 这是Stanford Web Services自助服务平台安装配置文件的主要帮助程序模块,并用作更多内容的基础。 辅助功能 该模块符合大学可访问性政策要求的AA WCAG 2.0级标准。 有关该政策的更多信息,请访问: : 。 安装 像...
  • python模块详解

    热门讨论 2012-02-29 21:06:35
    11.4. profile 模块 11.5. pstats 模块 11.6. tabnanny 模块 其他模块 12.1. 概览 12.2. fcntl 模块 12.3. pwd 模块 12.4. grp 模块 12.5. nis 模块 12.6. curses 模块 12.7. termios 模块 12.8. tty ...
  • profile和line_profiler两个模块都是性能分析工具。有时候需要找到代码中运行速度较慢处或瓶颈,可以通过这两模块实现,而不再使用time计时。 line_profiler模块可以记录每行代码的运行时间和耗时百分比。 memory_...
  • 阿拉贡简介 Aragon客户端的单个配置文件...import { Profile } from '@openworklabs/aragon-profile' const Example = ( ) => ( < Profile xss=removed xss=removed xss=removed xss=removed xss=removed> ) onSignat
  • 该示例可直接集成到Facebook ,并提供了一个很好的示例,说明了使用Profile模块将社交网络集成到您的游戏中有多么简单。 入门 从或获得Cocos2d-x框架。 确保使用最新稳定的cocos2d-x第3版(我们已通过v3.3 / v3.4...
  • MYSQL查询优化:profile功能

    万次阅读 2015-05-17 22:35:35
    这里还需要注意一点就是,需要安装profile模块才能实现。 1、不过版本要在5.0.37之后。(SHOW PROFILES and SHOW PROFILE were added in MySQL 5.0.37.) SELECT @@profiling; 来查看是否已经启用profile,...
  • terraform-aws-eks-fargate-profile 提供一个EKS节点组的Terraform模块。 对其进行多次实例化以创建具有特定设置(例如GPU,EC2实例类型或自动缩放参数)的许多EKS节点组。 该项目是我们针对DevOps的全面方法的一...
  • Profile

    2012-04-02 20:04:19
    1.profile可以干什么 一个Profile可以覆盖项目构件的最终名称,项目依赖,插件配置以影响构建行为。Profile还可以覆盖分发配置;例如,如果你通过一个staging profile发布一个构件到staging服务器上,你就可以创建...
  • profile> profiles> <activeProfiles> <activeProfile>profile1activeProfile> <activeProfile>profile2activeProfile> activeProfiles> profilesXml> 4. 典型案例 4.1. 设置 maven 私服 maven 私服设置往往是全局...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 97,688
精华内容 39,075
关键字:

profile模块