Python内置方法的时间复杂度(转)

原文:http://www.orangecube.net/python-time-complexity

本文翻译自Python Wiki
本文基于GPL v2协议,转载请保留此协议。

本页面涵盖了Python中若干方法的时间复杂度(或者叫“大欧”,“Big O”)。该时间复杂度的计算基于当前(译注:至少是2011年之前)的CPython实现。其他Python的实现(包括老版本或者尚在开发的CPython实现)可能会在性能表现上有些许小小的差异,但一般不超过一个O(log n)项。

本文中,’n’代表容器中元素的数量,’k’代表参数的值,或者参数的数量。

列表(list

以完全随机的列表考虑平均情况。

列表是以数组(Array)实现的。最大的开销发生在超过当前分配大小的增长,这种情况下所有元素都需要移动;或者是在起始位置附近插入或者删除元素,这种情况下所有在该位置后面的元素都需要移动。如果你需要在一个队列的两端进行增删的操作,应当使用collections.deque(双向队列)

操作 平均情况 最坏情况
复制 O(n) O(n)
append[注1] O(1) O(1)
插入 O(n) O(n)
取元素 O(1) O(1)
更改元素 O(1) O(1)
删除元素 O(n) O(n)
遍历 O(n) O(n)
取切片 O(k) O(k)
删除切片 O(n) O(n)
更改切片 O(k+n) O(k+n)
extend[注1] O(k) O(k)
排序 O(n log n) O(n log n)
列表乘法 O(nk) O(nk)
x in s O(n)  
min(s), max(s) O(n)  
计算长度 O(1) O(1)

双向队列(collections.deque

deque (double-ended queue,双向队列)是以双向链表的形式实现的 (Well, a list of arrays rather than objects, for greater efficiency)。双向队列的两端都是可达的,但从查找队列中间的元素较为缓慢,增删元素就更慢了。

操作 平均情况 最坏情况
复制 O(n) O(n)
append O(1) O(1)
appendleft O(1) O(1)
pop O(1) O(1)
popleft O(1) O(1)
extend O(k) O(k)
extendleft O(k) O(k)
rotate O(k) O(k)
remove O(n) O(n)

集合(set)

未列出的操作可参考 dict —— 二者的实现非常相似。

操作 平均情况 最坏情况
x in s O(1) O(n)
并集 s|t O(len(s)+len(t))  
交集 s&t O(min(len(s), len(t)) O(len(s) * len(t))
差集 s-t O(len(s))  
s.difference_update(t) O(len(t))  
对称差集 s^t O(len(s)) O(len(s) * len(t))
s.symmetric_difference_update(t) O(len(t)) O(len(t) * len(s))

由源码得知,求差集(s-t,或s.difference(t))运算与更新为差集(s.difference_uptate(t))运算的时间复杂度并不相同!前者是将在s中,但不在t中的元素添加到新的集合中,因此时间复杂度为O(len(s));后者是将在t中的元素从s中移除,因此时间复杂度为O(len(t))。因此,使用时请留心,根据两个集合的大小以及是否需要新集合来选择合适的方法。

集合的s-t运算中,并不要求t也一定是集合。只要t是可遍历的对象即可。

字典(dict)

下列字典的平均情况基于以下假设:
1. 对象的散列函数足够撸棒(robust),不会发生冲突。
2. 字典的键是从所有可能的键的集合中随机选择的。

小窍门:只使用字符串作为字典的键。这么做虽然不会影响算法的时间复杂度,但会对常数项产生显著的影响,这决定了你的一段程序能多快跑完。

操作 平均情况 最坏情况
复制[注2] O(n) O(n)
取元素 O(1) O(n)
更改元素[注1] O(1) O(n)
删除元素 O(1) O(n)
遍历[注2] O(n) O(n)

注:
[1] = These operations rely on the “Amortized” part of “Amortized Worst Case”. Individual actions may take surprisingly long, depending on the history of the container.

[2] = For these operations, the worst case n is the maximum size the container ever achieved, rather than just the current size. For example, if N objects are added to a dictionary, then N-1 are deleted, the dictionary will still be sized for N objects (at least) until another insertion is made.

时间: 2024-10-16 21:25:45

Python内置方法的时间复杂度(转)的相关文章

Python内置方法的时间复杂度

转载自:http://www.orangecube.NET/Python-time-complexity 本文翻译自Python Wiki 本文基于GPL v2协议,转载请保留此协议. 本页面涵盖了Python中若干方法的时间复杂度(或者叫"大欧","Big O").该时间复杂度的计算基于当前(译注:至少是2011年之前)的CPython实现.其他Python的实现(包括老版本或者尚在开发的CPython实现)可能会在性能表现上有些许小小的差异,但一般不超过一个O(

2017/9/11——何某某更博,花时间整理了所有的Python内置方法的用法,便于日后复习

1.这里是所有的内置方法的使用方法 # -*- coding:utf-8 -*- # Author : 何子辰 # 所有的内置方法总结 print('1.abs'.center(50,'*')) # abs 绝对值 a = abs(-5) print(a) print('2.all'.center(50,'*')) # all # Return True if all elements of the # iterable are true(or if the iterable # is empt

Python内置方法

1 #author F 2 3 #内置函数 4 print(abs(-5)) #绝对值 5 print(all([0, -5, 13])) #如果可迭代对象都为真 返回true 如果有不为真 返回false 6 print(any([0, -5, 13])) #如果有一个对象为真 返回true 如果都不为真 返回false 7 print(any([])) #false 8 a = ascii([1,2,3,"大苏打"]) 9 print(type(a), [a]) #ascii 把一

Python几种数据结构内置方法的时间复杂度

参考:https://blog.csdn.net/baoli1008/article/details/48059623 注:下文中,'n'代表容器中元素的数量,'k'代表参数的值,或者参数的数量. 1.列表(list) 以完全随机的列表考虑平均情况. 列表是以数组(Array)实现的. 最大的开销发生在超过当前分配大小的增长,这种情况下所有元素都需要移动:或者是在起始位置附近插入或者删除元素,这种情况下所有在该位置后面的元素都需要移动. 如果需要在一个队列的两端进行增删的操作,应当使用colle

Python 内置方法

1. abs() 取绝对值函数 1 #!/usr/bin/env python 2 # _*_ coding: UTF-8 _*_ 3 # Author:taoke 4 i = 100 5 print(abs(i)) 6 i = -100 7 print(abs(i)) 2.dict() 创建字典 1 print(dict({"a":1, "b":2, "c":3})) 3.help() 帮助函数 4.min() 返回最小项iterable或最小

Python内置方法/函数

abs() 返回数字的绝对值. abs(x) all() 用于判断给定的可迭代参数 iterable 中的所有元素是否都为 TRUE,如果是返回 True,否则返回 False. 元素除了是 0.空.None.False 外都算 True. all(iterable) #iterable -- 元组或列表 >>> all([1,2,0]) False >>> all([1,2,1]) True any() 用于判断给定的可迭代参数 iterable 是否全部为 Fals

Python 内置方法new

class Dog(object): def __new__(self): print("i am new .") def __init__(self): print("i am init .") def run(self): print("runing .") dog = Dog() dog.run() #打印i am new. #执行run()方法失败 #错误原因:没有生成dog对象,所以调用方法失败 class Dog(object): #

常用的python内置方法

all  ( )                                 循环参数,参数全为真就返回Ture any()                              只要有一个为真就返回ture bool()                            判断真假 ascii(对象)                          在对象的类中,找到_repr_方法,取其返回值 repr()                              找到_repr

Python中使用help查看某一类对象的内置方法

Python中不同类型的对象有不同的方法,那么如何查看某一类型对象的方法?我们可以使用help()函数 用法help() ,括号中写对象的类型.比如查看数据类型的方法: help(int)  |  Methods defined here:  |    |  __abs__(...)  |      x.__abs__() <==> abs(x)  |    |  __add__(...)  |      x.__add__(y) <==> x+y  |    |  __and__