• 【python学习】--执行时间计算方法以及优化

    系列文章目录

    文章目录

    前言

    一、时间不一致的猜想

    python脚本运行时间远远大于python脚本中统计的计算时间
    猜想：

    1. python中用到的是py2neo的写数据异步，阻塞进程运行；
    2. python脚本使用统计时间的方式是time.clock(),而这种方式统计的是CPU的执行时间，不是程序的执行时间。

    程序执行时间 = CPU运行时间 + IO时间 + 休眠或等待时间

    二、原因探索

    1.方法一

    import asyncio
import datetime
starttime = datetime.datetime.now()
# long running
# do something other

async def sayhi():
    print("你好，若竹")
    await asyncio.sleep(10)
    print("用余生去守护")

asyncio.run(sayhi())


endtime = datetime.datetime.now()
print(("程序运行时间为：")+ str((endtime-starttime).seconds)+"秒")

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    输出：

    你好，若竹
用余生去守护
程序运行时间为：10秒

    • 1
    • 2
    • 3

    datetime.datetime.now()获取的是当前日期，在程序执行结束之后，这个方式获得的时间值为程序执行的时间。

    2.方法二

    import asyncio
import datetime
import time

starttime = time.time()
# long running
# do something other

async def sayhi():
    print("你好，若竹")
    await asyncio.sleep(10)
    print("用余生去守护")

asyncio.run(sayhi())

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒")

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    输出：

    你好，若竹
用余生去守护
程序运行时间为：10.002257108688354秒

    • 1
    • 2
    • 3

    time.time()获取自纪元以来的当前时间（以秒为单位）。如果系统时钟提供它们，则可能存在秒的分数，所以这个地方返回的是一个浮点型类型。这里获取的也是程序的执行时间。

    2.方法三：

    import asyncio
import datetime
import time

starttime = time.clock()
# long running
# do something other

async def sayhi():
    print("你好，若竹")
    await asyncio.sleep(10)
    print("用余生去守护")

asyncio.run(sayhi())

endtime = time.clock()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒")

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    输出：

    .\py_study.py:807: DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead
  starttime = time.clock()
你好，若竹
用余生去守护
.\py_study.py:818: DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead
  endtime = time.clock()
程序运行时间为：10.0219916秒

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    Deprecation Warning: time. clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time. perf_counter or time. process_time instead
    弃用警告:时间。clock在Python 3.3中已弃用，并将从Python 3.8中移除:使用time。perf_counter或时间。process_time代替。

    代码如下：

    import asyncio
import datetime
import time

starttime = time.perf_counter()
# long running
# do something other

async def sayhi():
    print("你好，若竹")
    await asyncio.sleep(10)
    print("用余生去守护")

asyncio.run(sayhi())

endtime = time.perf_counter()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒")

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    输出：

    你好，若竹
用余生去守护
程序运行时间为：10.060287599999999秒

    • 1
    • 2
    • 3

    三、python 运行效率慢的原因

    1.简介

    编程语言的效率一方面指开发效率，即程序员完成编码所需的时间，另一方面是运行效率，即计算任务所需的时间。编码效率和运行效率往往很难兼顾。

    2.运行效率慢的原因

    1. python 是动态语言，造成运行时的不确定性影响运行效率；
      动态语言是一类在运行时可以改变其结构的语言，如新的函数、对象、代码可以被引入，已有的函数可以被删除或其他结构上的变化等，该类语言更具有活性，但是不可避免的因为运行时的不确定性也影响运行效率。数据的比较和转换类型的开销很大，每次读取、写入或引用一个变量，都要检查类型。很难优化一种极具动态性的语言。Python的许多替代语言之所以快得多，原因在于它们为了性能在灵活性方面作出了牺牲。

    2. python 是解释执行，不支持JIT（just in time compiler）;
      相比于C语言编译性语言编写的程序，Python是解释执行语言，其运行过程是Python运行文件程序时，Python解释器将源代码转换为字节码，然后再由Python解释器来执行这些字节码。其每次运行都要进行转换成字节码，然后再由虚拟机把字节码转换成机器语言，最后才能在硬件上运行，与编译性语言相比，其过程更复杂，性能肯定会受影响。

    3. python 中一切皆对象，每个对象都需要维护引用计数，增加额外工作；
      Python是一门面向对象的编程语言，其设计理念是一切皆是对象，如数字、字符串、元组、列表、字典、函数、方法、类、模块等都是对象，包括代码，每个对象都需要维护引用计数，因此，增加了额外工作，影响了性能。

    4. python GIL，全局解释器锁导致无法实现真正的并发；
      GIL是Python最为诟病的一点，因为GIL，Python中的多线程并不能真正的并发，即使在单线程，GIL也会带来很大的性能影响，因为python每执行100个opcode就会尝试线程的切换，因此，影响Python运行效率。

    5. 垃圾回收机制，会中断正在执行的程序，造成所谓的卡顿；
      Python采用标记和分代的垃圾回收策略，每次垃圾回收的时候都会中断正在执行的程序，造成所谓的顿卡，影响运行效率。

    四、python 优化

    1. 优化算法：时间复杂度
      算法的时间复杂度对程序的执行效率影响最大，在python 中可以通过选择合适的数据结构来优化时间复杂度，如list和set查找某一个元素的时间复杂度分别是O(n)和O(1).不同的场景有不同的优化方式，总的来说，一般有分治，分支界限，贪心，动态规划等。

    2. 减少冗余数据
      如用上三角或下三角的方式去保存一个大的对称矩阵。在0元素占大多数的矩阵里使用稀疏矩阵表示。

    3. 合理使用copy与deepcopy
      对于dict和list等数据结构的对象，直接赋值使用的是引用的方式。而有些情况下需要复制整个对象，这时可以使用copy包里的copy和deepcopy，这两个函数的不同之处在于后者是递归复制的。效率也不一样：(以下程序在ipython中运行)

    4. 使用dict或set查找元素

    5. 合理使用生成器(generator)和yield

    6. 优化循环

    7. 优化包含多个判断表达式的顺序

    8. 使用join合并迭代器中的字符串

    9. 选择合适的格式化字符方式

    10. 不借助中间变量交换两个变量的值

    11. 使用if is

    12. 使用级联比较x < y < z

    13. while 1 比 while True 更快

    14. 使用**而不是pow

    15. 使用 cProfile, cStringIO 和 cPickle等用c实现相同功能(分别对应profile, StringIO, pickle)的包

    16. 使用最佳的反序列化方式

    17. 使用C扩展(Extension)

    18. 并行编程

    19. 终级大杀器：PyPy

    20. 使用性能分析工具

    五、python 优化技巧

    python是一种脚本语言，相比C/C++这样的编译语言，在效率和性能方面存在一些不足。

    1.优化原则

    1. 不要过早优化，优化的前提是代码可以正常工作，过早优化可能会忽视对总体性能指标的把握，在得到全局结果前不要主次颠倒。
    2. 权衡优化的代价，想要解决所有性能问题是几乎不可能的，通常面临的选择是时间换空间或空间换时间，另外，还要考虑开发的代价。
    3. 优化关键位置。

    2.避免全局变量

    不推荐写法：

    import asyncio
import datetime
import time

import math

starttime = time.time()
# long running
# do something other

size = 10000
for x in range(size):
    for y in range(size):
        z = math.sqrt(x) + math.sqrt(y)

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒")

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    输出：

    程序运行时间为：32.05525302886963秒

    • 1

    推荐写法：

    import asyncio
import datetime
import time

import math

starttime = time.time()
# long running
# do something other

def main():  # 定义到函数中，以减少全局变量的使用
    size = 10000
    for x in range(size):
        for y in range(size):
            z = math.sqrt(x) + math.sqrt(y)
main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒")

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    输出：

    程序运行时间为：26.54142999649048秒

    • 1

    全局变量和局部变量实现方式不同，定义在全局范围内的代码运行速度会比定义在函数中慢不少，通常将脚本语句放入到函数中，可以带来15%-30%的速度提升。

    3.避免模块和函数属性访问

    不推荐写法：

    import asyncio
import datetime
import time

import math

starttime = time.time()
# long running
# do something other

def computeSqrt(size: int):
    result = []
    for i in range(size):
        result.append(math.sqrt(i))
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒")  

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    输出：

    程序运行时间为：17.07011365890503秒

    • 1

    每次使用.（属性访问操作符时）会触发特定的方法，如__getattribute__()和__getattr__()，这些方法会进行字典操作，因此会带来额外的时间开销。通过from import语句，可以消除属性访问。

    第一次优化：

    import asyncio
import datetime
import time

import math
from math import sqrt


starttime = time.time()
# long running
# do something other

def computeSqrt(size: int):
    result = []
    for i in range(size):
        #result.append(math.sqrt(i)) # 避免math.sqrt的使用
        result.append(sqrt(i))
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒")  

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    输出：

    程序运行时间为：14.559865236282349秒

    • 1

    上面我们讲到，局部变量的查找比全局变量更快，因此对于频繁访问的变量sqrt，通过将其改为局部变量可以加速运行。

    第二次优化：

    import asyncio
import datetime
import time

import math
from math import sqrt


starttime = time.time()
# long running
# do something other

def computeSqrt(size: int):
    result = []
    sqrt = math.sqrt  # 赋值给局部变量
    for i in range(size):
        result.append(sqrt(i)) # 避免math.sqrt的使用
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒")  

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    输出：

    程序运行时间为：14.179925203323364秒

    • 1

    除了math.sqrt外，computeSqrt函数中还有.的存在，那就是调用list的append方法。通过将该方法赋值给一个局部变量，可以彻底消除computeSqrt函数中for循环内部的.使用。

    推荐写法：

    import asyncio
import datetime
import time

import math
from math import sqrt

starttime = time.time()
# long running
# do something other

def computeSqrt(size: int):
    result = []
    append = result.append
    sqrt = math.sqrt # 赋值给局部变量
    for i in range(size):
        append(sqrt(i)) # 避免result.append和math.sqrt的使用
    return result

def main():
    size = 10000
    for _ in range(size):
        result = computeSqrt(size)

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒")  

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    输出：

    程序运行时间为：13.289391279220581秒

    • 1

    4.避免类内属性访问

    不推荐写法：

    import asyncio
import datetime
import time

import math
from typing import List

starttime = time.time()
# long running
# do something other

class DemoClass:
    def __init__(self, value: int):
        self._value = value
    
    def computeSqrt(self, size: int) -> List[float]:
        result = []
        append = result.append
        sqrt = math.sqrt
        for _ in range(size):
            append(sqrt(self._value))
        return result

def main():
    size = 10000
    for _ in range(size):
        demo_instance = DemoClass(size)
        result = demo_instance.computeSqrt(size)

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒") 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33

    输出：

    程序运行时间为：14.498187780380249秒

    • 1

    避免.的原则也适用于类内属性，访问self._value的速度会比访问一个局部变量更慢一些。通过将需要频繁访问的类内属性赋值给一个局部变量，可以提升代码运行速度。

    推荐写法：

    import asyncio
import datetime
import time

import math
from typing import List

starttime = time.time()
# long running
# do something other

class DemoClass:
    def __init__(self, value: int):
        self._value = value
    
    def computeSqrt(self, size: int) -> List[float]:
        result = []
        append = result.append
        sqrt = math.sqrt
        value = self._value
        for _ in range(size):
            append(sqrt(value)) # 避免self._value的使用
        return result

def main():
    size = 10000
    for _ in range(size):
        demo_instance = DemoClass(size)
        result = demo_instance.computeSqrt(size)

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒") 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    输出：

    程序运行时间为：12.744902849197388秒

    • 1

    5.避免不必要的抽象

    不推荐写法：

    import asyncio
import datetime
import time

import math
from typing import List

starttime = time.time()
# long running
# do something other

class DemoClass:
    def __init__(self, value: int):
        self._value = value
    
    @property
    def value(self) -> int:
        return self._value

    @value.setter
    def value(self, x: int):
        self._value = x

def main():
    size = 1000000
    for i in range(size):
        demo_instance = DemoClass(size)
        value = demo_instance.value
        demo_instance.value = i

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒") 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34

    输出:

    程序运行时间为：0.3770256042480469秒

    • 1

    任何时候当你使用额外的处理层（比如装饰器、属性访问、描述器）去包装代码时，都会让代码变慢。大部分情况下，需要重新进行审视使用属性访问器的定义是否有必要，使用getter/setter函数对属性进行访问通常是 C/C++ 程序员遗留下来的代码风格。如果真的没有必要，就使用简单属性。

    推荐写法：

    import asyncio
import datetime
import time

import math
from typing import List

starttime = time.time()
# long running
# do something other

class DemoClass:
    def __init__(self, value: int):
        self.value = value  # 避免不必要的属性访问器    

def main():
    size = 1000000
    for i in range(size):
        demo_instance = DemoClass(size)
        value = demo_instance.value
        demo_instance.value = i

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒") 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26

    输出：

    程序运行时间为：0.26129961013793945秒

    • 1

    6.避免数据复制

    1. 避免无意义的数据复制

    不推荐的写法：

    import asyncio
import datetime
import time

starttime = time.time()
# long running
# do something other

def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        value_list = [x for x in value]
        square_list = [x * x for x in value_list]

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒") 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19

    输出：

    程序运行时间为：7.3553197383880615秒

    • 1

    上面的代码中value_list完全没有必要，这会创建不必要的数据结构或复制。

    推荐写法：

    import asyncio
import datetime
import time

starttime = time.time()
# long running
# do something other

def main():
    size = 10000
    for _ in range(size):
        value = range(size)
        square_list = [x * x for x in value]  # 避免无意义的复制

main()

endtime = time.time()
print("程序运行时间为："+ str(float(endtime-starttime))+"秒") 

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    输出：

    程序运行时间为：5.667866230010986秒

    • 1

    另外一种情况是对 Python 的数据共享机制过于偏执，并没有很好地理解或信任 Python 的内存模型，滥用 **copy.deepcopy()之类的函数。通常在这些代码中是可以去掉复制操作的。

    1. 交换值时不使用中间变量

    总结

    分享：
    人的最高境界就是追求独立的精神价值，形成高度独立的人格。独立意识较强的人，有较强的理性和情绪调控能力，他的心灵深处拥有崇高、永恒的精神家园，生命从此不再空虚。

  • 相关阅读:
    Node.js 做 Web 后端的优势在哪？为什么是明智的选择？
    聊聊HttpClient的重试机制
    Python实战：读取MATLAB文件数据(.mat文件)
    基于Java+控制台实现教材管理系统
    从Mpx资源构建优化看splitChunks代码分割
    Linux—搭建Apache(httpd)服务
    RK3568 Android11 编译报错
    keil如何查看变量的实时值
    Dart 笔记：变量和内置类型
    [JavaWeb]—Mybatis入门
  • 原文地址：https://blog.csdn.net/qq_45365214/article/details/126139372