python数据结构的性能

2019-11-03 17:54:28 阅读：311 来源： 互联网

标签：__ timeit python 性能 list number range 数据结构 1000

2019-11-03　　16:07:33

## 对比*list*和*dict*操作

类型	list	dict
索引	i	key
添加	append、extend、insert	d[key] = value
删除	pop、remove*	pop
更新	l[i] = value	d[key] = value
正查	l[i]、l[i:j]	d[key]、copy
反查	index(value)、count(value)	/
其他	reverse、sort	has_key、update

原则上，常用操作性能最优

# list

对列表：最常用操作有

+ 按索引赋值取值：`l[i]=v` `v=l[i]`

+ 列表增长：

　　- append()

　　- __add()__

　　- "+"

四种生成前n个整数列表的方法

#循环连接
def test1():
    l = []
    for i in range(1000):
        l = l + [i]

#append()方法
def test2():
    l = []
    for i in range(1000):
        l.append(i)

#列表推导式
def test3():
    l = [i for i in range(1000)]

#range()函数调用转成列表
def test4():
    l = list(range(1000))

性能对比

from timeit import Timer

t1 = Timer("test1()", "from __main__ imporrt test1")
print("concat %f seconds\n" % t1.timeit(number = 1000))

t2 = Timer("test2()", "from __main__ imporrt test2")
print("append %f seconds\n" % t2.timeit(number = 1000))

t3 = Timer("test3()", "from __main__ imporrt test3")
print("comprehension %f seconds\n" % t3.timeit(number = 1000))

t4 = Timer("test4()", "from __main__ imporrt test4")
print("list range %f seconds\n" % t4.timeit(number = 1000))

- timeit模块Timer.timeit()方法[number]参数表示反复调用多少次

运行结果1<2<3<4

concat 1.082888 seconds
append 0.054237 seconds
comprehension 0.027933 seconds
list range 0.011302 seconds

## list.pop操作

比较pop()和pop(i)

import timeit
popzero = timeit.Timer("x.pop(0)", "from __main__ import x")
popend = timeit.Timer("x.pop()", "from __main__ import x")

x = list(range(2000000))
print(popzero.timeit(number=1000))

x = list(range(2000000))
print(popend.timeit(number=1000))

运行结果

1.5929707000000235
5.389999989802163e-05

比较两者时间增长趋势

print("\tpop(0)\t\t\tpop()")
for i in range(1000000,100000001,1000000):
    x = list(range(i))
    pt = popend.timeit(number=1000)
    x = list(range(i))
    pz = popzero.timeit(number=1000)
    print("%15.5f, %15.5f"%(pz,pt))

	pop(0)	　　　　　　pop()
        0.79530,         0.00007
        1.62498,         0.00006
        2.71965,         0.00007
        3.78712,         0.00006
        5.04768,         0.00006
        6.15274,         0.00006
        6.96183,         0.00007
        7.83566,         0.00007
        9.28867,         0.00007

肉眼可见的线性增长　　：　　不增长

# dict

最常用操作

- 取值get()

- 赋值set()

- 存在contains(in)

性能均为O(1)

import random
for i in range(10000,100001,10000):
    t = timeit.Timer("random.randrange(%d) in x" % i, "from __main__ import random, x")
    x = list(range(i))
    lst_time = t.timeit(number=1000)
    x = {j:None for j in range(i)}
    d_time = t.timeit(number=1000)
    print("%d,%10.3f,%10.3f" % (i,lst_time,d_time))

运行结果（规模，列表，字典）

　　　　10000,     0.047,     0.001
　　　　20000,     0.085,     0.001
　　　　30000,     0.129,     0.001
　　　　40000,     0.179,     0.001
　　　　50000,     0.220,     0.001
　　　　60000,     0.255,     0.001
　　　　70000,     0.311,     0.001
　　　　80000,     0.355,     0.001
　　　　90000,     0.376,     0.001
　　　　100000,     0.414,     0.001

肉眼可见的线性增长　　：　　无关规模

O(n)　　:　　O(1)

更多信息见官方wiki

https://wiki.python.org/moin/TimeComplexity

标签：__,timeit,python,性能,list,number,range,数据结构,1000
来源： https://www.cnblogs.com/ilyyfan/p/11788222.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9

python数据结构的性能