Python 常见API 及其时间复杂度

已于 2024-07-27 22:06:25 修改
阅读量900 收藏 17
点赞数 16
文章标签： python 算法 开发语言
于 2024-07-27 21:46:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nfty19/article/details/140741438
版权

Python常见的数据结构

list、deque、set和dict四种数据结构

列表list 时间复杂度

Python列表 (list) 中一些常见操作的具体API用法及时间复杂度说明：

1. Copy (复制)

  • API: new_list = old_list.copy()
  • Description: 创建一个列表的浅拷贝。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

2. Append (追加)

  • API: lst.append(item)
  • Description: 向列表末尾添加一个元素。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(1)

3. Pop (弹出)

  • API: item = lst.pop([index])
  • Description: 移除列表末尾的元素并返回它；如果提供了索引，则移除该位置的元素并返回。
  • Time Complexity:
    • Pop last: O(1)
    • Pop intermediate: O(n)

4. Insert (插入)

  • API: lst.insert(index, item)
  • Description: 在指定位置插入一个元素。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

5. Get Item (获取元素)

  • API: item = lst[index]
  • Description: 获取列表中指定索引处的元素。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(1)

6. Set Item (设置元素)

  • API: lst[index] = item
  • Description: 修改列表中指定索引处的元素。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(1)

7. Delete Item (删除元素)

  • API: del lst[index]
  • Description: 删除列表中指定索引处的元素。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

8. Iteration (迭代)

  • API: for item in lst: ...
  • Description: 遍历列表中的每个元素。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

9. Get Slice (获取切片)

  • API: slice = lst[start:end:step]
  • Description: 获取列表的一部分。
  • Time Complexity:
    • Average Case: O(k)
    • Amortized Worst Case: O(k)

10. Del Slice (删除切片)

  • API: del lst[start:end:step]
  • Description: 删除列表的一部分。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

11. Set Slice (设置切片)

  • API: lst[start:end:step] = other_sequence
  • Description: 替换列表的一部分。
  • Time Complexity:
    • Average Case: O(k + n)
    • Amortized Worst Case: O(k + n)

12. Extend (扩展)

  • API: lst.extend(other_sequence)
  • Description: 将另一个序列的元素添加到列表末尾。
  • Time Complexity:
    • Average Case: O(k)
    • Amortized Worst Case: O(k)

13. Sort (排序)

  • API: lst.sort(key=None, reverse=False)
  • Description: 就地排序列表。
  • Time Complexity:
    • Average Case: O(n log n)
    • Amortized Worst Case: O(n log n)

14. Multiply (重复)

  • API: new_list = lst * k
  • Description: 重复列表 k 次。
  • Time Complexity:
    • Average Case: O(nk)
    • Amortized Worst Case: O(nk)

15. Membership Test (成员测试)

  • API: item in lst
  • Description: 检查元素是否存在于列表中。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

16. Min/Max (最小/最大值)

  • API: min_val = min(lst), max_val = max(lst)
  • Description: 找到列表中的最小值或最大值。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

17. Get Length (获取长度)

  • API: length = len(lst)
  • Description: 获取列表的长度。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(1)
OperationAverage CaseAmortized Worst Case
CopyO(n)O(n)
AppendO(1)O(1)
Pop lastO(1)O(1)
Pop intermediateO(n)O(n)
InsertO(n)O(n)
Get ItemO(1)O(1)
Set ItemO(1)O(1)
Delete ItemO(n)O(n)
IterationO(n)O(n)
Get SliceO(k)O(k)
Del SliceO(n)O(n)
Set SliceO(k + n)O(k + n)
ExtendO(k)O(k)
SortO(n log n)O(n log n)
MultiplyO(nk)O(nk)
x in sO(n)O(n)
min(s), max(s)O(n)O(n)
Get LengthO(1)O(1)

这里，“n”代表列表中的元素总数，“k”代表操作影响的元素数量。例如，在切片操作中，“k”是切片长度。对于append和extend操作，由于列表在内部可能需要重新分配内存来容纳更多的元素，因此在某些情况下这些操作可能需要更多的时间，但是从长远来看，它们的时间复杂度被摊销为O(1)。

collections.deque 时间复杂度

collections.deque（双端队列）的一些常见操作的具体API用法及其时间复杂度说明：

1. Copy (复制)

  • API: new_deque = old_deque.copy()
  • Description: 创建一个deque的浅拷贝。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

2. append (追加)

  • API: dq.append(item)
  • Description: 在deque的右侧追加一个元素。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(1)

3. appendleft (左侧追加)

  • API: dq.appendleft(item)
  • Description: 在deque的左侧追加一个元素。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(1)

4. pop (弹出)

  • API: item = dq.pop()
  • Description: 移除deque右侧的元素并返回它。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(1)

5. popleft (左侧弹出)

  • API: item = dq.popleft()
  • Description: 移除deque左侧的元素并返回它。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(1)

6. extend (扩展)

  • API: dq.extend(iterable)
  • Description: 从右侧将iterable中的元素依次追加到deque。
  • Time Complexity:
    • Average Case: O(k)
    • Amortized Worst Case: O(k)

7. extendleft (左侧扩展)

  • API: dq.extendleft(iterable)
  • Description: 从左侧将iterable中的元素逆序追加到deque。
  • Time Complexity:
    • Average Case: O(k)
    • Amortized Worst Case: O(k)

8. rotate (旋转)

  • API: dq.rotate(n=1)
  • Description: 将deque中的元素向右旋转n次。如果n为负数，则向左旋转。
  • Time Complexity:
    • Average Case: O(k)
    • Amortized Worst Case: O(k)

9. remove (移除)

  • API: dq.remove(value)
  • Description: 从deque中移除第一个出现的value。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

10. Get Length (获取长度)

  • API: length = len(dq)
  • Description: 获取deque的长度。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(1)

deque的设计旨在提供高效的两端操作，因此append, appendleft, pop, popleft等操作都是常数时间复杂度。而remove操作则需要线性时间，因为它需要遍历deque以找到要移除的第一个匹配项。

OperationAverage CaseAmortized Worst Case
CopyO(n)O(n)
appendO(1)O(1)
appendleftO(1)O(1)
popO(1)O(1)
popleftO(1)O(1)
extendO(k)O(k)
extendleftO(k)O(k)
rotateO(k)O(k)
removeO(n)O(n)
Get LengthO(1)O(1)

集合set 时间复杂度

Python set（集合）的一些常见操作的具体API用法及其时间复杂度说明：

1. Membership Test (成员测试)

  • API: item in s
  • Description: 检查元素是否存在于集合中。
  • Time Complexity:
    • Average Case: O(1)
    • Worst Case: O(n)

2. Union (并集)

  • API: union_set = s.union(t)
  • Description: 返回一个新的集合，包含两个集合中的所有不同元素。
  • Time Complexity:
    • Average Case: O(len(s) + len(t))
    • Worst Case: O(len(s) + len(t))

3. Intersection (交集)

  • API: intersection_set = s.intersection(t)
  • Description: 返回一个新的集合，包含两个集合中共有的元素。
  • Time Complexity:
    • Average Case: O(min(len(s), len(t)))
    • Worst Case: O(len(s) * len(t))
    • Notes: 如果t不是集合，则时间复杂度为 O(max(len(s), len(t))).

4. Multiple Intersection (多个集合交集)

  • API: multiple_intersection_set = s1.intersection(s2, ..., sn)
  • Description: 返回一个新的集合，包含多个集合中共有的元素。
  • Time Complexity:
    • Average Case: (n-1) * O(l) 其中 l 是 max(len(s1), ..., len(sn))
    • Worst Case: 不适用（实际情况下，取决于实现细节）

5. Difference (差集)

  • API: difference_set = s.difference(t)
  • Description: 返回一个新的集合，包含s中但不在t中的元素。
  • Time Complexity:
    • Average Case: O(len(s))
    • Worst Case: O(len(s))

6. Difference Update (差集更新)

  • API: s.difference_update(t)
  • Description: 就地修改s，移除与t中相同的元素。
  • Time Complexity:
    • Average Case: O(len(t))
    • Worst Case: O(len(s) * len(t))

7. Symmetric Difference (对称差集)

  • API: symmetric_difference_set = s.symmetric_difference(t)
  • Description: 返回一个新的集合，包含在s或t中但不在两者都出现的元素。
  • Time Complexity:
    • Average Case: O(len(s))
    • Worst Case: O(len(s) * len(t))

8. Symmetric Difference Update (对称差集更新)

  • API: s.symmetric_difference_update(t)
  • Description: 就地修改s，使其成为s和t的对称差集。
  • Time Complexity:
    • Average Case: O(len(t))
    • Worst Case: O(len(t) * len(s))

集合的实现通常基于哈希表，这意味着大多数操作的时间复杂度在平均情况下接近常数时间，但在最坏的情况下可能会退化为线性时间。特别是当哈希冲突发生时，某些操作的时间复杂度可能会增加。

OperationAverage caseWorst Casenotes
x in sO(1)O(n)
Union s&tO(len(s)+len(t))
Intersection s&tO(min(len(s), len(t)))O(len(s) * len(t))replace “min” with “max” if t is not a set
Multiple intersection s1&s2&…&sn(n-1)*O(l where l is max(len(s1),…len(sn))
Difference s-tO(len(s))
s.difference_update(t)O(len(t))O(len(s) * len(t))
Symmetric Difference s^tO(len(s))O(len(s) * len(t))
s.symmetric_difference_update(t)O(len(t))O(len(t) * len(s))

字典dict 时间复杂度

Python dict（字典）的一些常见操作的具体API用法及其时间复杂度说明：

1. Membership Test (成员测试)

  • API: key in d
  • Description: 检查键是否存在于字典中。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(n)

2. Copy (复制)

  • API: new_dict = old_dict.copy()
  • Description: 创建一个字典的浅拷贝。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

3. Get Item (获取元素)

  • API: value = d[key]
  • Description: 根据键获取对应的值。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(n)

4. Set Item (设置元素)

  • API: d[key] = value
  • Description: 添加键值对或更新已存在的键的值。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(n)

5. Delete Item (删除元素)

  • API: del d[key]
  • Description: 删除字典中指定键的条目。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(n)

6. Iteration (迭代)

  • API: for key in d: ...
  • Description: 遍历字典中的每个键。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)

7. Additional Operations (其他操作)

Get Method (安全获取元素)
  • API: value = d.get(key, default)
  • Description: 获取字典中键对应的值，如果键不存在则返回默认值。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(n)
Items and Keys (获取键值对和键)
  • API: items = d.items(), keys = d.keys()
  • Description: 获取字典中的键值对或键的视图。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)
Values (获取值)
  • API: values = d.values()
  • Description: 获取字典中所有的值的视图。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)
Pop (弹出)
  • API: value = d.pop(key, default)
  • Description: 移除并返回字典中指定键的值，如果键不存在则返回默认值。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(n)
Popitem (弹出键值对)
  • API: key_value = d.popitem()
  • Description: 移除并返回字典中的任意一个键值对。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(n)
Clear (清空)
  • API: d.clear()
  • Description: 清空字典。
  • Time Complexity:
    • Average Case: O(n)
    • Amortized Worst Case: O(n)
Setdefault (设置默认值)
  • API: value = d.setdefault(key, default)
  • Description: 如果键不存在，则使用默认值设置键值对并返回该值；如果键存在，则返回对应的值。
  • Time Complexity:
    • Average Case: O(1)
    • Amortized Worst Case: O(n)
Update (更新)
  • API: d.update(other_dict)
  • Description: 将另一个字典的内容合并到当前字典中。
  • Time Complexity:
    • Average Case: O(m) 其中 m 是 other_dict 的长度
    • Amortized Worst Case: O(m * n)

字典的实现通常基于哈希表，这意味着大多数操作的时间复杂度在平均情况下接近常数时间，但在最坏的情况下可能会退化为线性时间。特别是当哈希冲突发生时，某些操作的时间复杂度可能会增加。

OperationAverage CaseAmortized Worst Case
k in dO(1)O(n)
Copy[3]O(n)O(n)
Get ItemO(1)O(n)
Set Item[1]O(1)O(n)
Delete ItemO(1)O(n)
Iteration[3]O(n)O(n)

（补充）构造方法

1. List (列表)

  • API: list([iterable])
  • Description: 创建一个列表。如果提供了可迭代对象，则会从该对象构建列表。
  • Example:
    # 使用空列表
lst = list()

# 使用给定的可迭代对象构建列表
lst = list(range(5))
print(lst)  # 输出: [0, 1, 2, 3, 4]

2. Deque (双端队列)

  • API: collections.deque([iterable[, maxlen]])
  • Description: 创建一个双端队列。如果提供了可迭代对象，则会从该对象构建deque。maxlen参数可选，用于限制deque的最大长度。
  • Example:
    from collections import deque

# 使用空deque
dq = deque()

# 使用给定的可迭代对象构建deque
dq = deque(range(5))
print(dq)  # 输出: deque([0, 1, 2, 3, 4])

# 使用最大长度构建deque
dq = deque(range(5), maxlen=3)
print(dq)  # 输出: deque([2, 3, 4], maxlen=3)

3. Set (集合)

  • API: set([iterable])
  • Description: 创建一个集合。如果提供了可迭代对象，则会从该对象构建集合。集合中的元素是唯一的。
  • Example:
    # 使用空集合
s = set()

# 使用给定的可迭代对象构建集合
s = set([1, 2, 3, 3, 4, 4, 4])
print(s)  # 输出: {1, 2, 3, 4}

4. Dict (字典)

  • API: dict([mapping, **kwargs]) 或 dict(iterable)
  • Description: 创建一个字典。如果提供了映射对象，则会从该对象构建字典。也可以通过关键字参数初始化字典。如果提供了可迭代对象，则假设它是键值对的元组组成的序列。
  • Example:
    # 使用空字典
d = dict()

# 使用关键字参数构建字典
d = dict(a=1, b=2, c=3)
print(d)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# 使用给定的可迭代对象构建字典
d = dict([(1, 'one'), (2, 'two')])
print(d)  # 输出: {1: 'one', 2: 'two'}
NFTY19
关注
人工智能大模型原理与应用实战：AI模型转换为API的步骤和方法
AI天才研究院
11-06 1022
传统的开发模式下，构建复杂的软件系统是非常费时费力的，而通过云计算、微服务等技术手段可以实现快速部署、弹性扩展的能力。在这种背景下，越来越多的公司将重点转移到研发人员的产品思维上，希望能够将自己的AI模型转换为一个可供他人调用的API接口。但是对于许多从事AI领域的研发人员来说，如何将自己的AI模型转换为API是一个比较棘手的问题。在这篇文章中，作者将从AI模型转换为API的过程分为以下几个步骤：AI模型准备阶段——模型选择、数据准备、模型训练。
Python数据分析实战：物流业数据分析
AI天才研究院
02-19 1014
在当今快速发展的全球经济中，物流业作为连接生产和消费的重要纽带，正面临着前所未有的机遇与挑战。随着电子商务的蓬勃发展和消费者对快速、高效配送的需求不断增长，物流公司需要更智能、更精准的决策支持系统来优化其运营流程、提高服务质量并降低成本。然而，物流业每天产生的海量数据往往未被充分利用，其中蕴含的巨大价值尚待挖掘。这些数据包括但不限于订单信息、配送路线、车辆状态、仓储管理等各个环节的详细记录。如何有效地收集、处理、分析这些数据，并从中提取有价值的洞察，成为了物流业亟待解决的关键问题。
python常用机器学习库api文档
04-08
其中包含scipy、matplotib、scikti-learn、numpy、pandas文档，截至上传时间为最新版
python 常用api
Al_xin的专栏
06-28 624
1. 用法 从json str 转成json for line in f: data = json.loads(line) one_data = data.values() 按照文本顺序 from collections import OrderedDict for line in f: data = json.loads(line, object_pairs_hook=Orde...
Python学习笔记11-算法：排序算法
最新发布
08-22 384
简单排序（如冒泡、选择、插入排序）适用于小规模数据或教学目的。分治排序（如合并排序、快速排序）适用于中到大规模数据。堆排序和基数排序适用于特定场景，基数排序通常用于处理整数数据。不同的排序算法有不同的优缺点，选择合适的排序算法可以提高程序的效率和性能。
python 常用API
lbaihao的专栏
05-08 1517
1.在程序开发中，常常会遇到这样的需求：在执行对象中的某个方法，或者在调用对象的某个变量，但是由于一些原因，我们无法确定或者并不知道该方法或者变量是否存在，这时我们需要一个特殊的方法或者机制来访问或操作该未知的方法或变量，这种机制就被称之为反射。 ...
python常用api
microzzzf的博客
08-02 944
python常用api
常用Python的API
weixin_43963453的博客
09-01 582
常用PythonAPI一、网络相关1.下载网络文件到指定目录^[1]2.二、系统相关1.系统号三、12 一、网络相关 1.下载网络文件到指定目录1 官网文档 urllib.request.urlretrieve(url, filename=None, reporthook=None, data=None) 2. 二、系统相关 1.系统号 sys.version_info 在学习“机器学习实战”遇到的 三、12 121221 2: 在学习“机器学习实战”遇到的 1 ↩︎ 1 ↩︎ ...
python面试常见的25个问题.docx
12-16
Python提供了核心API来访问这些内存管理功能。 - **垃圾回收**：Python内置了垃圾回收机制，可以自动回收未使用的内存，使其可供其他程序使用。 #### 四、调试工具 - **PyChecker**：一个静态分析工具，用于检查...
Python代码性能优化指南：复杂度分析助你提升算法效率
![Python算法复杂度分析工具]...为了优化Python代码性能，首先需要理解算法的复杂度理论，这是评估代码效率的基础。接着，深入分析Python的数据结构性能，因为合适的数据结构使用是性能
Python 人工智能实战：自动驾驶
AI天才研究院
10-20 837
人工智能（Artificial Intelligence，AI）是指通过机器学习、模式识别、数据挖掘等技术让计算机“思考”和“学习”，从而实现智能化。这一领域在近几年取得了极大的进步，逐渐成为当今最热门的话题。2017 年底，谷歌推出 AlphaGo，它是一个基于强化学习（Reinforcement Learning，RL）算法的围棋游戏 AI。2019 年，DeepMind 提出的星际争霸游戏 AI “AlphaStar” 也突破了人类级别的表现。
pythonAPI（帮助文档）
02-21
此为python开发者适用文档
pythonAPI文档
04-25
python API 文档 参考 官方 备份 学习
python常用api_python进行各类API的使用
weixin_39967812的博客
11-20 215
import requestsimport optparseimport jsondef main():usage='usage:[-i IP query]'\'[-m National wifi lat]'\'[-l National wifi lon]'\'[-x Daily News]'\'[-t Info querry]'parser=optparse.OptionParser(usage...
Python-文件对象常用的API
代码就是生产力！https://yannanxiu.cn/
05-25 1322
Python的文件对象是由C语言的stdio包实现，并且可以用内置的open()函数创建。 文件对象会由一些其它内置的函数和方法返回，如os.popen()和os.fdopen()以及套接字对象的makefile()方法。临时文件可以通过tempfile模块创建，高级的文件操作如复制、移动和删除文件和目录可以通过shutil模块完成。 当文件操作由于I/O原因失败时，将引发IOError异常。它包括出于某种原因该操作未定义的情况，比如在tty设备上seek()或写入只为读取打开的文件。
webdriver-python常用api
怕什么真理无穷，进一寸有一寸的欢喜
07-28 2140
from selenium import webdriver driver = webdriver.Firefox() driver.get("http://www.baidu.com") # 访问百度首页 driver.maximize_window() # 窗口最大化 driver.get("http://news.baidu.com") # 访问百度新闻页
常用API之Python
ping96的博客
03-14 2503
常用API之Python笔记
Python中的算法时间复杂度
九久的博客
04-23 693
文章目录python内置类型性能分析timeit模块list和dict python内置类型性能分析 timeit模块 timeit模块可以用来测试一小段Python代码的执行速度。 该模块下里面有个Timer类，其参数为： class timeit.Timer(stmt='pass',setup='pass',timer=<timer function>) 其中： Timer是测量...
Python 基础API
七七的博客
12-27 6404
文章目录一、python运行代码片段二、在Windows系统中从终端运行Python程序三、变量3.1 变量名四、 错误反馈Traceback五、字符串5.1 字符串大小写5.2 合并字符串5.3 制表符\t5.4 换行符\n5.5 字符串删除空白rstrip()、lstrip()5.6 四则运算5.7 str()函数：int型转string 整型转字符型5.8 注释六、列表6.1 添加元素、删除元素的几种方式6.2 元素排序list.sort、sorted(list)6.3 反转元素排列顺序list.re
Python后端开发：bootstrapping_tools库0.4.0版本发布
Python的库生态系统非常丰富，它拥有大量的第三方库，这些库覆盖了从数据分析、人工智能到网络爬虫、Web开发等多个领域，大大减少了开发者的开发时间和复杂度。 在这些库中，“bootstrapping_tools-0.4.0.tar.gz”...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值