Python内置类型性能分析

在测试一个方法或者代码的性能时，一般我们可以使用time模块，通过在测试代码前和后分别调用time.time()方法，在通过两个时间相减来计算出调用代码所用的时间。

import time
begin = time.time()
……
测试代码块
……
final = time.time()
print(final - begin)

在Python中有一个timeit模块可以很方便的完成这个任务。

timeit模块

class timeit.Timer(stmt=‘pass’, setup=‘pass’, timer=<timer function )
Timer是测量小段代码执行速度的类。

stmt参数是要测试的代码语句（statment）；

setup参数是运行代码时需要的设置；

timer参数是一个定时器函数，与平台有关。

timeit.Timer.timeit(number=1000000)
Timer类中测试语句执行速度的对象方法。number参数是测试代码时的测试次数，默认为1000000次。方法返回执行代码的平均耗时，一个float类型的秒数。

list的操作测试

创建list的方式有4中：

• 两个list相加
• 用append（）在尾部追加
• 列表解析
• range（）函数

值得注意的是range函数返回的是一个可迭代对象（类型是对象），而不是列表类型， 所以我们直接输入range(10),得到的并不是一个列表，而是一个range(1,10),它只是在迭代的情况下返回指定索引的值，但是它并不会在内存中真正产生一个列表对象，这样也是为了节约内存空间。

我们称这种对象是可迭代的，或者是可迭代对象，还有一种对象叫迭代器，它们需要从一个可迭代对象中连续获取指定索引的值，一直到索引结束。list()函数就是这样一个迭代器，它可以把range()函数返回的对象变成一个列表。

from timeit import Timer
def t1():
	l=[]
	for i in range(1000):
		l=l+[i]
def t2():
	l=[]
	for i in range(1000):
		l.append(i)
def t3():
	l=[ i for i in range(1000)]
def t4():
	l=list(range(1000))
	
	
time1=Timer("t1","from __main__ import t1")
print("concat ",time1.timeit(number=1000), "seconds")
time2=Timer("t2","from __main__ import t2")
print("append ",time2.timeit(number=1000), "seconds")
time3=Timer("t3","from __main__ import t3")
print("comprehension  ",time3.timeit(number=1000), "seconds")
time4=Timer("t4","from __main__ import t4")
print("list range ",time4.timeit(number=1000), "seconds")

# ('concat ', 1.7890608310699463, 'seconds')
# ('append ', 0.13796091079711914, 'seconds')
# ('comprehension ', 0.05671119689941406, 'seconds')
# ('list range ', 0.014147043228149414, 'seconds')

pop操作测试

x = range(2000000)
pop_zero = Timer("x.pop(0)","from __main__ import x")
print("pop_zero ",pop_zero.timeit(number=1000), "seconds")
x = range(2000000)
pop_end = Timer("x.pop()","from __main__ import x")
print("pop_end ",pop_end.timeit(number=1000), "seconds")

# ('pop_zero ', 1.9101738929748535, 'seconds')
# ('pop_end ', 0.00023603439331054688, 'seconds')

list内置操作的时间复杂度

dict内置操作的时间复杂度