1.高并发响应性能非常好,官方Nginx处理静态文件并发5w/s

第十一章 追求速度

Python异常对代码运行性能的影响实例解析,python实例

2.反向代码性能非常强(可用于负载均衡)

  • 优化是一个悬浮在软件开发上的幽灵,很多编程错误都是以效率的名义犯下的。
  • “优化”指改善某个事物以使它更好,对于更好,从不同方面看,有不同的理解:1.
    使程序运行速度更快;2. 减少可执行文件的大小;3. 提高代码的质量;4.
    提高计算结果的准确性;5. 将启动时间减到最小;6. 增加数据的吞吐量;7.
    减少存储开销。
  • 对于优化,建议如下:不要做优化。
  • 一种错误的想法:只有在开发结束使你的代码运行的不够快的情况下,再考虑是否进行优化。
  • 代码的性能由许多因素决定,包括:1. 程序执行的平台;2.
    部署和安装的配置;3. 体系结构软件方面的决策;4. 低级的模块设计;5.
    遗留的历史问题;6. 每行源代码的质量。
  • 要从一开始就要考虑你的程序的性能,而不是置之不理。
  • 正确的代码远远比速度快的代码重要,快速得到错误的结果是毫无意义的。所以我们应该花更多的精力去证明代码运行是正确的。

    性能问题的产生可能基于以下几个原因:

  • 复杂性。不必要的复杂性是一个杀手,需要做的工作越多,代码就会运行的越慢。
  • 间接。所有的问题都可以由一个额外的间接层来解决。但是间接也产生了大量的抽象。
  • 重复。
  • 糟糕的设计。糟糕的设计必然导致糟糕的代码,它可能是导致最基本的、最细微的和最难解决的性能问题。
  • I/O。一个总是等待输入或输出的程序,其性能注定会非常糟糕。

    为什么不进行优化呢,因为优化代码是将一种良好的特性与另一种相交换的行为,代码的某些方面将受到伤害,表现在以下几个方面:

  • 可读性的损失。大部分“优化”的代码都非常凌乱,非常难懂。
  • 复杂性的增加。复杂性是优秀代码的敌人。
  • 难以维护/扩展。优化之所以会妨碍代码的可扩展性,是因为它常常来源于进行更多的设想。
  • 引入了冲突。优化往往是基于某个平台,为一种处理器选择最优的数据类型,可能会导致其他处理器上较慢的运行速度。
  • 更多的努力。我们需要关注优化工作的优先级。

  • 寻找对代码进行优化的替代方案,你能以任何其他方式提高你的程序的性能吗?尽可能不要通过修改代码的方式进行优化。

  • 我们在做软件项目时,需求文档中很少会对性能作出规定,但是如果你的程序运行的太慢,用户就会抱怨。
  • 理解你何时才确实需要对代码进行优化,最好是从一开始就编写高效和高质量的代码。

    我们是程序的运行速度加快,可以分为以下几个步骤:

  • 确定程序运行的太慢,并证明你的确需要进行优化。
  • 找出运行的最慢的代码,以这段代码为目标。
  • 测试这段作为优化目标的代码的性能。
  • 对这段代码进行优化。
  • 测试优化后的代码是否仍然可以正常运行(非常重要)。
  • 测试速度增加了多少,并决定下一步做什么。

  • 在开始优化时,有一个清晰的目标非常重要。

  • 为了正确的进行优化,你必须很小心,以防止外部因素改变你的代码的运行方式。
  • 单独优化你的代码,与所有其他工作都分开,这样一项任务的结果就不会影响其他任务。
  • 我们应该忽略较小的效率,在97%的时间里我们都能说,不成熟的优化是万恶之源。
  • 80/20原则在程序中的运用:平均来看程序超过80%的运行时间会花在少于20%的代码上。

    查找程序中影响性能的代码段,可以采取以下的方法:

  • 在代码中随处放置一些手动的计时器进行测试。
  • 计算每个函数的调用频率。
  • 利用编译器提供的钩子,在进入和退出每个函数的地方插入你自己的计数代码。
  • 对程序计数器进行取样。
  • 通过让单个函数变慢来测试它对整个程序执行时间的影响。

  • 尝试分析几个不同的数据集,观察结果有什么不同,选择一个非常基本的数据集、一个高负荷的数据集和一些普通的数据集。

  • 性能不足的原因也许不是某个具体的函数,而是一个涉及面更大的设计上的缺陷。不要只依赖于分析器来查找程序效率低下的原因,你也许会错过重要的问题。
  • 你必须在对代码修改之前和修改之后都要对性能进行测试,以确保你的修改确实使代码不同,并却确保修改确实使代码变更更好。永远不要在没有执行前后性能评估的情况下尝试对代码进行优化。
  • 不要忘记对优化后的代码进行评测,以证明你所做的是一个成功的修改。
  • 清晰的代码要好过有限的优化。
  • 常用的优化技术包括:设计更改和代码更改。与几行糟糕的源代码相比,抵消的设计更能束缚程序的效率。
  • 大多数情况下我们的优化目标是提高代码的运行速度,优化策略是:1.
    加快较慢代码的速度;2. 尽量少做较慢的事情;3.
    将较慢的事情推迟到不得不进行的时候再做。
  • 设计更改是宏观层面上的优化,即在较大的范围内进行修改,以改善软件的内部设计。
  • 在对程序中使用的算法进行优化时,最好使用较快的算法来代替较慢的算法,而不要胡乱的修补算法的具体实现。

    代码更改时,通常要打开编译器优化功能,或增加优化水平,常用的方法包括:

  • 循环展开。对于主题非常短的循环,循环的框架也许比循环执行的操作本身还要耗费资源。
  • 代码内嵌。通过合并调用方和被调用方来移除对函数的调用,可以提高代码的性能。
  • 常量叠算。可以在编译时进行涉及常量值的运算,以减少运行时的工作量。
  • 移到编译时,许多条件测试可以静态的加以验证,并从代码中移除,有些测试可以完全被避免。
  • 强度折减。指用一个等价但是执行速度更快的操作来代替某个操作,通常都是位运算。
  • 子表达式。
  • 无用代码删除。

  • 我们需要在设计时就进行性能方面的考虑,在设计每个模块时,不要盲目的追求性能,如果你知道需要什么样的性能水平,那么为适当的效率而设计就会更容易一些。

  • 在优化时,要非常系统,并权衡各种因素,要有一个清晰的目标,并证明每个步骤都使你更加接近目标。让可靠的代码而不是你的直觉来引导你。

  • 优秀的程序员:1. 避免进行优化,除非证明绝对需要;2.
    系统的进行优化,采用深思熟虑和经过权衡的方法;3.
    在求助于代码级优化之前,积极地寻找替代方案,并尝试设计级的改进;4.
    更喜欢不会破坏代码质量的优化。

  • 糟糕的程序员:1. 在证明代码速度不够之前就开始进行优化;2.
    非常轻率,不进行权衡或研究就改动哪些他们认为是瓶颈的代码;3.
    从不从宏观地角度考虑:他们的优化在其他代码区域和使用模式中意味着什么;4.
    认为速度比代码的质量更重要。

前言

Python的异常处理能力非常强大,但是用不好也会带来负面的影响。我平时写程序的过程中也喜欢使用异常,虽然采取防御性的方式编码会更好,但是交给异常处理会起到偷懒作用。偶尔会想想异常处理会对性能造成多大的影响,于是今天就试着测试了一下。

3.内存和cpu占比率低(为Apache的1/5-1/10);

Python异常(谷歌开源风格指南)

4.对后端服务有健康检查功能

tip:

允许使用异常, 但必须小心。

5.支持 PHP cgi方式和fastcgi方式

定义:

异常是一种跳出代码块的正常控制流来处理错误或者其它异常条件的方式。

6.配置代码简介且容易上手

优点:

正常操作代码的控制流不会和错误处理代码混在一起. 当某种条件发生时,
它也允许控制流跳过多个框架. 例如, 一步跳出N个嵌套的函数,
而不必继续执行错误的代码。

缺点:

可能会导致让人困惑的控制流. 调用库时容易错过错误情况。

结论:

异常必须遵守特定条件:

像这样触发异常:
raise MyException("Error message")或者raise MyException.
不要使用两个参数的形式( raise MyException, "Error message"
)或者过时的字符串异常( raise "Error message" )。
模块或包应该定义自己的特定域的异常基类,
这个基类应该从内建的Exception类继承. 模块的异常基类应该叫做”Error”。

class Error(Exception):
  pass 

永远不要使用 except: 语句来捕获所有异常, 也不要捕获 Exception 或者
StandardError, 除非你打算重新触发该异常,
或者你已经在当前线程的最外层(记得还是要打印一条错误消息). 在异常这方面,
Python非常宽容,except: 真的会捕获包括Python语法错误在内的任何错误.
使用 except: 很容易隐藏真正的bug。

尽量减少try/except块中的代码量. try块的体积越大,
期望之外的异常就越容易被触发. 这种情况下,
try/except块将隐藏真正的错误。

使用finally子句来执行那些无论try块中有没有异常都应该被执行的代码.
这对于清理资源常常很有用, 例如关闭文件。
当捕获异常时, 使用 as 而不要用逗号. 例如

try:
  raise Error
except Error as error:
  pass

设计实验方式

采取比较简单直观的对照实验。

先定义一个装饰器,用来计算每个函数执行所需时间:

def timer(func):
  import time
  def wrapper(*args, **kwargs):
    startTime = time.time()
    f = func(*args, **kwargs)
    endTime = time.time()
    passTime = endTime - startTime
    print "执行函数%s使用了%f秒" % (getattr(func, "__name__"), passTime)
    return f
  return wrapper

然后用该装饰器装饰测试的函数即可。

再定义一个叫do_something的函数,这个函数中就做一件事,把1赋值给变量a。在每个测试函数中,都会调用这个函数1000000次。

do_something:

def do_something():
  a = 1

我根据情况设计了不同的测试组:

测试组1(直接执行耗时操作):

@timer
def test1():
  for _ in xrange(1000000):
    do_something()

测试组2(耗时操作放在try中执行,不抛出错误):

@timer
def test2():
  try:
    for _ in xrange(1000000):
      do_something()
  except Exception:
    do_something()
  else:
    pass
  finally:
    pass

测试组3(try放耗时操作中,try每一次操作,不抛出错误):

@timer
def test3():
  for _ in xrange(1000000):
    try:
      do_something()
    except Exception:
      do_something()
    else:
      pass
    finally:
      pass

必发官网手机版,测试组4(try放耗时操作中,try每一次操作并进行异常处理(捕捉抛出的特定异常)):

@timer
def test4():
  zero = 0
  for _ in xrange(1000000):
    try:
      if zero == 0:
        raise ZeroDivisionError
    except ZeroDivisionError:
      do_something()
    else:
      pass
    finally:
      pass

测试组5(try放耗时操作中,try每一次操作并进行异常处理(捕捉所有异常
try…except BaseException)):

@timer
def test5():
  zero = 0
  for _ in xrange(1000000):
    try:
      if zero == 0:
        raise ZeroDivisionError
    except BaseException:
      do_something()
    else:
      pass
    finally:
      pass

测试组6(try放耗时操作中,try每一次操作并进行异常处理(捕捉所有异常
不带任何异常类型)):

@timer
def test6():
  zero = 0
  for _ in xrange(1000000):
    try:
      if zero == 0:
        raise ZeroDivisionError
    except:
      do_something()
    else:
      pass
    finally:
      pass

测试组7(耗时操作放在except中):

@timer
def test7():
  zero = 0
  try:
    if zero == 0:
      raise ZeroDivisionError
  except ZeroDivisionError:
    for _ in xrange(1000000):
      do_something()
  else:
    pass
  finally:
    pass

测试组8(防御式编码):

@timer
def test8():
  zero = 0
  for _ in xrange(1000000):
    if zero == 0:
      do_something()

执行结果

必发官网手机版 1

对比结论

  • 通过对比1和2,可以得知直接执行耗时操作和耗时操作放在try中执行并无异常触发时性能消耗几乎是一样的。
  • 通过对比2和7,可以得知使用异常的使用无论是把代码放在 try
    中执行还是在 except 中执行性能消耗几乎是一样的。
  • 通过对比2和3,可以得知当不抛出错误时,把try放耗时操作中比耗时操作放在try中性能消耗要略大。
  • 通过对比3和4,可以得知当使用try时无异常抛出跟使用try时抛出异常性能消耗几乎相差好几倍。
  • 通过对比4和5,可以得知try放耗时操作中时,try每一次操作并进行异常处理(捕捉抛出的特定异常)跟try每一次操作并进行异常处理(捕捉所有异常
    try…except BaseException)性能消耗几乎是一样的。
  • 通过对比4和8,可以得知使用防御性方式编码比捕捉异常方式性能消耗几乎相差好几倍。
  • 通过对比5和6,可以得知捕捉所有异常(try…except)方式比捕捉所有异常(try…except
    BaseException)方式要略快。

总结

  1. 由以上对比结论,可以总结为:
  2. 无论是把代码放在 try 中执行还是在 except
    中执行性能消耗几乎是一样的。
  3. 直接执行代码与放在try中执行且不抛出异常时性能消耗几乎是一样的,当然理论上try会消耗一点性能,可以忽略不计。
  4. 虽然try…except的方式比try…except
    BaseException和捕捉抛出的特定异常的方式要略快,但扔不建议采取这种方式,因为前者很容易隐藏真正的bug,从而带来严重后果。
  5. 通常要采取捕捉抛出的特定异常而不是捕捉所有异常,虽然二者性能消耗几乎一样。
  6. 防御性方式编码比捕捉异常方式性能消耗几乎相差好几倍,应尽量采取这种编程方式,提升性能并且更靠谱。

以上就是本文关于Python异常对代码运行性能的影响实例解析的全部内容,希望对大家有所帮助。感兴趣的朋友可以继续参阅本站其他相关专题,如有不足之处,欢迎留言指出。感谢朋友们对本站的支持!

前言
Python的异常处理能力非常强大,但是用不好也会带来负面的影响。我平时写程序…

相关文章