第壹，函數調用優化(空間跨度，避免訪問內存)
程序優化的重點是最小化運行跨度，包括代碼執行的時間跨度和內存中的空間跨度。
1.大數據求和，用sum。
a =範圍(100000)
%timeit -n 10 sum(a)
10次循環，3次最佳:每次循環3.15毫秒
%%timeit
...:s = 0
...:對於我在a:
...:s += i
...：
100次循環，3次最佳:每次循環6.93毫秒
2.對小數據求和，避免使用sum。
% time It-n 1000s = A+B+C+D+E+F+G+H+I+J+K #數據量小的時候直接累加比較快。
1000個環路，最佳3:571 ns/環路
% timeit-n1000s = sum ([A，B，C，D，E，F，G，H，I，J，K]) #小數據調用sum函數，降低了空間效率。
1000個環路，每個環路最好為3: 669 ns
結論:大數據求和效率高，小數據求和效率高。
第二，for循環優化的要素(使用堆棧或寄存器來避免訪問內存)
Forlstin [(1，2，3)，(4，5，6)]: # lst索引需要額外的開銷。
及格
應該盡可能避免使用索引。
對於[(1，2，3)，(4，5，6)]中的a，b，c:#更好
及格
這相當於直接給每個元素賦值。
定義力():
lst =範圍(4)
對於[1，2]中的a1:
對於lst中的a2:
對於lst中的a3:
對於lst中的b1:
對於lst中的b2:
對於lst中的b3:
對於lst中的c1:
對於lst中的c2:
對於lst中的c3:
對於lst中的d1:
產量(a1，a2，a3，b1，b2，b3，c1，c2，c3，d1)
%%timeit -n 10
對於生效的t():
sum([t[0]，t[1]，t[2]，t[3]，t[4]，t[5]，t[6]，t[7]，t[8]，t[9])
10次循環，每次循環最好為3: 465毫秒
%%timeit -n 10
對於a1、a2、a3、b1、b2、b3、c1、c2、c3、d1生效():
sum([a1，a2，a3，b1，b2，b3，c1，c2，c3，d1])
10次循環，每次循環最好為3: 360毫秒
三、發電機優化(查表代替運算)
Def force(start，end): #用於密碼暴力破解程序。
對於範圍內的I(開始，結束):
現在=我
子列表= []
對於範圍(10)內的j:
sublist . append(I % 10)#除法比乘法開銷大。
i //= 10
sublst.reverse()
yield(tuple(sublist)，now)
def force(): #更好
lst =範圍(5)
對於[1]中的a1:
對於lst中的a2:
對於lst中的a3:
對於lst中的b1:
對於lst中的b2:
對於lst中的b3:
對於lst中的c1:
對於lst中的c2:
對於lst中的c3:
對於lst中的d1:
產量(a1，a2，a3，b1，b2，b3，c1，c2，c3，d1)
R0 = [1，2] #可讀性和靈活性
r1 =範圍(10)
R2 = R3 = R4 = r5 = R6 = r7 = r8 = r9 = r 1
force = ((a0，a1，a2，a3，a4，a5，a6，a7，a8，a9)
對於r0中的a0對於r65438中的a1對於r2中的a2對於r3中的a3對於r4中的a4
對於r5中的a5對於r6中的a6對於r7中的a7對於r8中的a8對於r9中的a9)
四、冪運算優化(pow(x，y，z))
def isprime(n):
如果n & amp1 == 0:
返回False
k，q = find_kq(n)
a = randint(1，n - 1)
如果pow(a，q，n) == 1: #比使用** q% n運算好幾倍。
返回True
對於範圍(k)中的j:
如果pow(a，pow(2，j) * q，n) == n - 1: # a **((2 ** j) * q) % n
返回True
返回False
結論:pow(x，y，z)優於x * * y% z。
動詞 （verb的縮寫）除法運算的優化
In [1]:從隨機導入getrandbits
In [2]: x = getrandbits(4096)
在[3]中:y = getrandbits(2048)
In [4]: %timeit -n 10000 q，r = divmod(x，y)
10000個循環，最佳3:10.7 us/循環
In [5]: %timeit -n 10000 q，r = x//y，x % y
10000個循環，最佳3: 265438+每個循環0.2 us
結論:divmod優於//和%。
6.優化算法的時間復雜度
算法的時間復雜度對程序的執行效率影響最大。在python中，可以選擇合適的數據結構來優化時間復雜度。例如，在list和set中搜索壹個元素的時間復雜度分別為O(n)和O(1)。不同的場景有不同的優化方法，壹般來說有分而治之、分支定界、貪婪動態規劃等思路。
七、合理使用copy和deepcopy
對於dict、list等數據結構的對象，直接賦值是通過引用。在某些情況下，您需要復制整個對象，因此您可以在復制包中使用copy和deepcopy。這兩個函數的區別在於，deepcopy是遞歸復制的。不同的效率:
在[23]:導入副本
in[24]:% time it-n 10 copy . copy(a)
10個環路，每個環路最好為3: 606 ns
in[25]:% time it-n 10 copy . deepcopy(a)
10個循環，每個循環3: 1.17 us
timeit後的-n表示運行次數，最後兩行對應兩個timeit的輸出，下同。這說明後者慢了壹個數量級。
復制的壹個例子:
& gt& gt& gt列表= [[]] * 3
& gt& gt& gt列表
[[], [], []]
& gt& gt& gt列表[0]。追加(3)
& gt& gt& gt列表
[[3], [3], [3]]
發生的情況是[[]]是壹個只有壹個元素包含空列表的列表，所以[[]] * 3的三個元素都是(指向)這個空列表。修改列表中的任何元素都會修改該列表。改性效率高。
八、利用dict或set尋找元素。
Python字典和集合是用哈希表實現的(類似c++標準庫unordered_map)，查找元素的時間復雜度為O(1)。
在[1]中:r =範圍(10**7)
In [2]: s = set(r) #占用588MB內存。
In [3]: d = dict ((I，1) for I in r) #占用內存716MB。
in[4]:% time it-n 10000(10 * * 7)-1 in r
10000個環路，最佳3: 2965438+每個環路0 ns
in[5]:% time it-n 10000(10 * * 7)-1 in s
10000個環路，最佳3個:每個環路121 ns
in[6]:% time it-n 10000(10 * * 7)-1 in d
10000個環路，最佳3個:每個環路111 ns
結論:set具有最小的內存占用和最短的字典運行時間。
九、合理使用(生成器)和產量(節省內存)
in[1]:% time it-n 10a =(I for I in range(10 * * 7))#生成器通常遍歷效率更高。
10次循環，每次循環最好為3: 933 ns
in[2]:% time it-n 10 a =[I for I in range(10 * * 7)]
10次循環，每次循環3: 916毫秒
in[1]:% time it-n 10 for x in(I for I in range(10 * * 7)):pass
10次循環，每次循環最好為3: 749毫秒
in[2]:% time it-n 10 for x in[I for I in range(10 * * 7)]:通過
10次循環，每次循環3: 1.05秒
結論:盡量使用生成器遍歷。