Python基础（十四） Python之禅与时间复杂度分析_快速找到最大值 时间复杂度

如果你也是看准了Python，想自学Python，在这里为大家准备了丰厚的免费学习大礼包，带大家一起学习，给大家剖析Python兼职、就业行情前景的这些事儿。

一、Python所有方向的学习路线

Python所有方向路线就是把Python常用的技术点做整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

二、学习软件

工欲善其必先利其器。学习Python常用的开发软件都在这里了，给大家节省了很多时间。

三、全套PDF电子书

书籍的好处就在于权威和体系健全，刚开始学习的时候你可以只看视频或者听某个人讲课，但等你学完之后，你觉得你掌握了，这时候建议还是得去看一下书籍，看权威技术书籍也是每个程序员必经之路。

四、入门学习视频

我们在看视频学习的时候，不能光动眼动脑不动手，比较科学的学习方法是在理解之后运用它们，这时候练手项目就很适合了。

四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。

五、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

成为一个Python程序员专家或许需要花费数年时间，但是打下坚实的基础只要几周就可以，如果你按照我提供的学习路线以及资料有意识地去实践，你就有很大可能成功！
最后祝你好运！！！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than right now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea – let’s do more of those!

* Beautiful is better than ugly


整齐、易读胜过混乱、晦涩


* Simple is better than complex


简约胜过复杂


* Complex is better than complicated


复杂胜过晦涩


* Flat is better than nested


扁平胜过嵌套


* Now is better than never.
* Although never is often better than right now.


理解一：先行动起来，编写行之有效的代码，不要企图一开始就编写完美无缺的代码


理解二：做比不做要好，但是盲目的不加思考的去做还不如不做


* If the implementation is hard to explain, it’s a bad idea.
* If the implementation is easy to explain, it may be a good idea.


如果方案很难解释，很可能不是有一个好的方案，反之亦然


##### 一些感悟


1、首先要行动起来，编写行之有效的代码；


2、如果都能解决问题，选择更加简单的方案；


3、整齐、易读、可维护性、可扩展性好；


4、强壮、健壮、鲁棒性好；


5、响应速度快，占用空间少。


**有些时候，鱼和熊掌不可兼得，根据实际情况进行相应的取舍**


### 14.2 时间复杂度分析


##### 14.2.1 代数分析


**求最大值和排序**

import numpy as np
x = np.random.randint(100, size=10)
x

array([13, 14, 33, 79, 18, 26, 17, 65, 87, 63])

* 寻找最大值的时间复杂度为O(n)
* 选择排序时间复杂度O(n^2)


**代数分析**

def one(x):
“”“常数函数”“”
return np.ones(len(x))

def log(x):
“”“对数函数”“”
return np.log(x)

def equal(x):
“”“线性函数”“”
return x

def n_logn(x):
“”“nlogn函数”“”
return x*np.log(x)

def square(x):
“”“平方函数”“”
return x**2

def exponent(x):
“”“指数函数”“”
return 2**x

import matplotlib.pyplot as plt
plt.style.use(“seaborn-whitegrid”)

t = np.linspace(1, 20, 100)
methods = [one, log, equal, n_logn, square, exponent]
method_labels = [“$y=1$”, “$y=log(x)$”, “$y=x$”, “$y=xlog(x)$”, “$y=x^2$”, “$y=2^x$”]
plt.figure(figsize=(12, 6))
for method, method_label in zip(methods, method_labels):
plt.plot(t, method(t), label=method_label, lw=3)
plt.xlim(1, 20)
plt.ylim(0, 40)
plt.legend()

<matplotlib.legend.Legend at 0x22728098e80>

![image-20221003194339678](https://img-blog.csdnimg.cn/img_convert/821524c3f1ad8d60511b75ff95760a04.png)


**我们的最爱：常数函数和对数函数**


**勉强接受：线性函数和nlogn函数**


**难以承受：平方函数和指数函数**


##### 14.2.2 三集不相交问题


问题描述：


假设有A、B、C三个序列，任一序列内部没有重复元素，欲知晓三个序列交集是否为空

import random
def creat_sequence(n):
A = random.sample(range(1, 1000), k=n)
B = random.sample(range(1000, 2000), k=n)
C = random.sample(range(2000, 3000), k=n)
return A, B, C

A, B, C = creat_sequence(100)
def no_intersection_1(A, B, C):
for a in A:
for b in B:
for c in C:
if a == b == c:
return False
return True

%timeit no_intersection_1(A, B, C)
no_intersection_1(A, B, C)

36.7 ms ± 2.12 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)

True

def no_intersection_2(A, B, C):
for a in A:
for b in B:
if a == b: # 如果相等再进行遍历，否则就返回上一级
for c in C:
if a == c:
return False
return True

%timeit no_intersection_2(A, B, C)

301 µs ± 37.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

import time

res_n_3 = []
res_n_2 = []

for n in [10, 20, 100]:
A, B, C = creat_sequence(n)
start_1 = time.time()
for i in range(100):
no_intersection_1(A, B, C)
end_1 = time.time()
for i in range(100):
no_intersection_2(A, B, C)
end_2 = time.time()
res_n_3.append(str(round((end_1 - start_1)*1000))+“ms”)
res_n_2.append(str(round((end_2 - end_1)*1000))+“ms”)

print(“{0:<23}{1:<15}{2:<15}{3:<15}”.format(“方法”, “n=10”, “n=20”, “n=100”))
print(“{0:<25}{1:<15}{2:<15}{3:<15}”.format(“no_inte rsection_1”, *res_n_3))
print(“{0:<25}{1:<15}{2:<15}{3:<15}”.format(“no_intersection_2”, *res_n_2))

方法 n=10 n=20 n=100
no_inte rsection_1 6ms 42ms 4001ms
no_intersection_2 0ms 1ms 24ms

##### 14.2.3 元素唯一性问题


问题描述：A 中的元素是否唯一

def unique_1(A):
for i in range(len(A)):
for j in range(i+1, len(A)):
if A[i] == A[j]:
return False
return True

def unique_2(A):
A_sort = sorted(A)
for i in range(len(A_sort)-1):
if A[i] == A[i+1]:
return False
return True

时间复杂度为O(nlogn)

import random
res_n_2 = []
res_n_log_n = []

for n in [100, 1000]:
A = list(range(n))
random.shuffle(A)
start_1 = time.time()
for i in range(100):
unique_1(A)
end_1 = time.time()
for i in range(100):
unique_2(A)
end_2 = time.time()
res_n_2.append(str(round((end_1 - start_1)*1000))+“ms”)
res_n_log_n.append(str(round((end_2 - end_1)*1000))+“ms”)

print(“{0:<13}{1:<15}{2:<15}”.format(“方法”, “n=100”, “n=1000”))
print(“{0:<15}{1:<15}{2:<15}”.format(“unique_1”, *res_n_2))
print(“{0:<15}{1:<15}{2:<15}”.format(“unique_2”, *res_n_log_n))

方法 n=100 n=1000
unique_1 49ms 4044ms
unique_2 1ms 21ms

##### 14.2.4 第n个斐波那契数


a(n+2) = a(n+1) + a(n)

def bad_fibonacci(n):
if n <= 1:
return n
else:
return bad_fibonacci(n-2)+ bad_fibonacci(n-1)

###### O(2^n)

def good_fibonacci(n):
i, a, b = 0, 0, 1
while i < n:
a, b = b, a+b
i += 1
return a

3

###### O(n)

%timeit bad_fibonacci(10)

20.6 µs ± 1.15 µs per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit good_fibonacci(10)

875 ns ± 24.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

##### 14.2.5 最大盛水容器


![image-20221003194433772](https://img-blog.csdnimg.cn/img_convert/e2f503fa4b5ec3feebf894134513bb62.png)


**暴力求解——双循环**

def max_area_double_cycle(height):
“”“暴力穷举双循环”“”
i_left, i_right, max_area = 0,0,0
for i in range(len(height)-1):
for j in range(i+1, len(height)):
area = (j-i) * min(height[j], height[i])
if area > max_area:
i_left, i_right, max_area = i, j, area
return i_left, i_right, max_area

height = np.random.randint(1, 50, size=10)
print(height)
max_area_double_cycle(height)

[10 11 41 26 2 44 26 43 36 30]

(2, 8, 216)

import matplotlib.pyplot as plt

plt.bar(range(10), height, width=0.5)
plt.xticks(range(0, 10, 1))

现在能在网上找到很多很多的学习资源，有免费的也有收费的，当我拿到1套比较全的学习资源之前，我并没着急去看第1节，我而是去审视这套资源是否值得学习，有时候也会去问一些学长的意见，如果可以之后，我会对这套学习资源做1个学习计划，我的学习计划主要包括规划图和学习进度表。



分享给大家这份我薅到的免费视频资料，质量还不错，大家可以跟着学习

![](https://img-blog.csdnimg.cn/img_convert/21b2604bd33c4b6713f686ddd3fe5aff.png)



**网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。**

**[需要这份系统化学习资料的朋友，可以戳这里获取](https://bbs.csdn.net/topics/618317507)**

**一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！**