python数据结构的性能

Posted ilyyfan

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了python数据结构的性能相关的知识，希望对你有一定的参考价值。

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
" % t1.timeit(number = 1000))

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

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

t4 = Timer("test4()", "from __main__ imporrt test4")
print("list range %f seconds
" % 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("	pop(0)			pop()")
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

以上是关于python数据结构的性能的主要内容，如果未能解决你的问题，请参考以下文章

性能有瓶颈？3 个实时可视化 Python 工具包来帮你！

14.VisualVM使用详解15.VisualVM堆查看器使用的内存不足19.class文件--文件结构--魔数20.文件结构--常量池21.文件结构访问标志（2个字节）22.类加载机制概(代码片段

常用python日期日志获取内容循环的代码片段

python 有用的Python代码片段

Python 向 Postman 请求代码片段

python [代码片段]一些有趣的代码#sort