res = “”
for x in strings:
res += x[:3]
return res
%timeit concat_strings_2(strings)
1.32 ms ± 19.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
2.4 .join方法套用生成器表达式
平均运行时间1.06毫秒。
def concat_strings_3(strings):
return “”.join(x[:3] for x in strings)
%timeit concat_strings_3(strings)
1.06 ms ± 15.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
2.5 .join方法套用列表解析式
平均运行时间0.85毫秒。
def concat_strings_4(strings):
return “”.join([x[:3] for x in strings])
%timeit concat_strings_4(strings)
858 µs ± 14.5 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
3. 筛选奇数
输入一个列表，要求筛选出该列表中的所有奇数。最终性能提升了3.6倍。
首先创建一个长度为10000的列表。
arr = list(range(10000))
3.1 最常规的写法
创建一个空列表res，while循环遍历列表，将奇数append到res中。平均运行时间1.03毫秒。
def filter_odd_0(arr):
res = []
i = 0
n = len(arr)
while i < n:
if arr[i] % 2:
res.append(arr[i])
i += 1
return res
%timeit filter_odd_0(arr)
1.03 ms ± 34.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
3.2 for range代替while循环
避免i += 1的变量类型检查带来的额外开销。平均运行时间0.965毫秒。
def filter_odd_1(arr):
res = []
for i in range(len(arr)):
if arr[i] % 2:
res.append(arr[i])
i += 1
return res
%timeit filter_odd_1(arr)
965 µs ± 4.02 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
3.3 for x in arr代替for range
避免arr[i]的变量类型检查带来的额外开销。平均运行时间0.430毫秒。
def filter_odd_2(arr):
res = []
for x in arr:
if x % 2:
res.append(x)
return res
%timeit filter_odd_2(arr)
430 µs ± 9.25 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
3.4 list套用filter函数
平均运行时间0.763毫秒。注意filter函数很慢，在Python 3.6里非常鸡肋。
def filter_odd_3(arr):
return list(filter(lambda x: x % 2, arr))
%timeit filter_odd_3(arr)
763 µs ± 15.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
3.5 list套用生成器表达式
平均运行时间0.398毫秒。
def filter_odd_4(arr):
return list((x for x in arr if x % 2))
%timeit filter_odd_4(arr)
398 µs ± 16.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
3.6 带条件的列表推导式
平均运行时间0.290毫秒。
def filter_odd_5(arr):
return [x for x in arr if x % 2]
%timeit filter_odd_5(arr)
290 µs ± 5.54 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
4. 两个数组相加
输入两个长度相同的列表，要求计算出两个列表对应位置的数字之和，返回一个与输入长度相同的列表。最终性能提升了2.7倍。
首先生成两个长度为10000的列表。
arr1 = list(range(10000))
arr2 = list(range(10000))
4.1 最常规的写法
创建一个空列表res，while循环遍历列表，将两个列表对应的元素之和append到res中。平均运行时间1.23毫秒。
def arr_sum_0(arr1, arr2):
i = 0
n = len(arr1)
res = []
while i < n:
res.append(arr1[i] + arr2[i])
i += 1
return res
%timeit arr_sum_0(arr1, arr2)
1.23 ms ± 3.77 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
4.2 for range代替while循环
避免i += 1的变量类型检查带来的额外开销。平均运行时间0.997毫秒。
def arr_sum_1(arr1, arr2):
res = []
for i in range(len(arr1)):
res.append(arr1[i] + arr2[i])
return res
%timeit arr_sum_1(arr1, arr2)
997 µs ± 7.42 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
4.3 for i, x in enumerate代替for range
部分避免arr[i]的变量类型检查带来的额外开销。平均运行时间0.799毫秒。
def arr_sum_2(arr1, arr2):
res = arr1.copy()
for i, x in enumerate(arr2):
res[i] += x
return res
%timeit arr_sum_2(arr1, arr2)
799 µs ± 16.7 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
4.4 for x, y in zip代替for range
避免arr[i]的变量类型检查带来的额外开销。平均运行时间0.769毫秒。
def arr_sum_3(arr1, arr2):
res = []
for x, y in zip(arr1, arr2):
res.append(x + y)
return res
%timeit arr_sum_3(arr1, arr2)
769 µs ± 12.2 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
4.5 列表推导式套用zip
平均运行时间0.462毫秒。
def arr_sum_4(arr1, arr2):
return [x + y for x, y in zip(arr1, arr2)]
%timeit arr_sum_4(arr1, arr2)
462 µs ± 3.43 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
5. 两个列表相同元素的数量
输入两个列表，要求统计两个列表相同元素的数量。其中每个列表内的元素都是不重复的。最终性能提升了5000倍。
首先创建两个列表，并将元素的顺序打乱。
from random import shuffle
arr1 = list(range(2000))
shuffle(arr1)
arr2 = list(range(1000, 3000))
shuffle(arr2)
5.1 最常规的写法
while循环嵌套，判断元素arr1[i]是否等于arr2[j]，平均运行时间338毫秒。
def n_common_0(arr1, arr2):
res = 0
i = 0
m = len(arr1)
n = len(arr2)
while i < m:
j = 0
while j < n:
if arr1[i] == arr2[j]:
res += 1
j += 1
i += 1
return res
%timeit n_common_0(arr1, arr2)
338 ms ± 7.81 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
5.2 for range代替while循环
避免i += 1的变量类型检查带来的额外开销。平均运行时间233毫秒。
def n_common_1(arr1, arr2):
res = 0
for i in range(len(arr1)):
for j in range(len(arr2)):
if arr1[i] == arr2[j]:
res += 1
return res
%timeit n_common_1(arr1, arr2)
233 ms ± 10.9 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
5.3 for x in arr代替for range
避免arr[i]的变量类型检查带来的额外开销。平均运行时间84.8毫秒。
def n_common_2(arr1, arr2):
res = 0
for x in arr1:
for y in arr2:
if x == y:
res += 1
return res
%timeit n_common_2(arr1, arr2)
84.8 ms ± 1.38 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
5.4 使用if x in arr2代替内层循环
平均运行时间24.9毫秒。
def n_common_3(arr1, arr2):
res = 0
for x in arr1:
if x in arr2:
res += 1
return res
%timeit n_common_3(arr1, arr2)
24.9 ms ± 1.39 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
5.4 使用更快的算法
将数组用.sort方法排序，再进行单层循环遍历。把时间复杂度从O(n2)降低到O(nlogn)，平均运行时间0.239毫秒。
def n_common_4(arr1, arr2):
arr1.sort()
arr2.sort()
res = i = j = 0
m, n = len(arr1), len(arr2)
while i < m and j < n:
if arr1[i] == arr2[j]:
res += 1
i += 1
j += 1
elif arr1[i] > arr2[j]:
j += 1
else:
i += 1
return res
%timeit n_common_4(arr1, arr2)
329 µs ± 12.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
5.5 使用更好的数据结构
将数组转为集合，求交集的长度。平均运行时间0.067毫秒。
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数Python工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）
长或者是报班学习，但对于培训机构动则几千的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！**
因此收集整理了一份《2024年Python开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-rlDBKrST-1713806241538)]
[外链图片转存中…(img-E2InNGKy-1713806241539)]
[外链图片转存中…(img-yGuPdWDq-1713806241539)]
[外链图片转存中…(img-dAk1BsDw-1713806241540)]
既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上前端开发知识点，真正体系化！
由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新
如果你觉得这些内容对你有帮助，可以扫码获取！！！（备注：Python）
514
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
