try的简单性能测试

copy
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
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110

# 1.测试对函数类型检查使用捕捉异常和if先判断方式的时间差
from timeit import timeit

def increment_lbyl(x):
    if isinstance(x, int):
        return x + 1
    elif isinstance(x, str) and x.isdigit():
        return int(x) + 1
    else:
        pass
        # raise ValueError("Invalid input")

def increment_eafp(x):
    try:
        return int(x) + 1
    except (TypeError, ValueError):
        pass
        # raise ValueError("Invalid input")

t_lbyl_75 = timeit(setup="from __main__ import increment_lbyl", stmt="increment_lbyl(75)", number=10_000_000)
t_eafp_75 = timeit(setup="from __main__ import increment_eafp", stmt="increment_eafp(75)", number=10_000_000)

print(f"lbyl_75: {t_lbyl_75:.4f} seconds")
print(f"eafp_75: {t_eafp_75:.4f} seconds")

t_lbyl_75_s = timeit(setup="from __main__ import increment_lbyl", stmt="increment_lbyl('75')", number=10_000_000)
t_eafp_75_s = timeit(setup="from __main__ import increment_eafp", stmt="increment_eafp('75')", number=10_000_000)

print(f"lbyl_'75': {t_lbyl_75:.4f} seconds")
print(f"eafp_'75': {t_eafp_75:.4f} seconds")

t_lbyl_invalid = timeit(setup="from __main__ import increment_lbyl", stmt="increment_lbyl('invalid')", number=10_000_000)
t_eafp_invalid = timeit(setup="from __main__ import increment_eafp", stmt="increment_eafp('invalid')", number=10_000_000)

print(f"lbyl_invalid: {t_lbyl_invalid:.4f} seconds")
print(f"eafp_invalid: {t_eafp_invalid:.4f} seconds")

# lbyl_75: 0.4216 seconds
# eafp_75: 0.5533 seconds
# lbyl_'75': 0.4216 seconds
# eafp_'75': 0.5533 seconds
# lbyl_invalid: 0.7271 seconds
# eafp_invalid: 5.6974 seconds

# 当前版本Python 3.11.0 可以看到使用异常捕获方式始终比先判断方式慢一点，可见异常捕获会有额外的性能损耗
# 但是说实话二者差距非常小，只有异常时，异常捕获方式明显占用更多时间，但也不到10倍差距
# 最重要的是，这是在1千万次循环的情况下暴露出来的，实际上二者的差距非常小
# 如果基本保证函数输入大部分是正确的，那么使用异常捕获方式可读性更好、更易于维护




# 2.即使函数return了，finally也会执行，那么会暂时保留局部变量吗，以及finally修改返回值内容影响返回
def f(x):
    try:
        x += 1
        return x
    finally:
        x = 0
        return x
    
print(f(0))

# amazing啊，这个函数返回的是0，去掉finally里的return才能返回1
# 可见确实函数return后了也要执行finally，且finally甚至能重新return一个值
# 另外，finally的x=0并不会影响try里的return。
# 我认为局部变量x的值是被改变了的，但是执行顺序上，return x中x应该已经被计算了，
# 所以finally如果没有return的话，是不会覆盖前面的return内容的


def g(x):
    try:
        x += '1'
        return x
    finally:
        x = '0'
        # return x
    
print(g('0'))

# 改为字符串也是同理

# 查看f函数的字节码
def f_bytecode(x): # 对比f函数的字节码
    x += 1
    return x
    
import dis
print(dis.dis(f))
print(dis.dis(f_bytecode))



def f():
    try:
        x = 1
        raise Exception
        y = 'y'
    except:
        print(x)
        # print(y)
    finally:
        x = 0
        print(x)
        # print(y)
f()

# except和finally都输出了，说明try里没异常之前的内容都是真实存在的
# 但是异常之后的内容都没有

本文作者：faf4r

本文链接：https://www.cnblogs.com/faf4r/p/18378382

版权声明：本作品采用知识共享署名-非商业性使用-禁止演绎 2.5 中国大陆许可协议进行许可。