Python 성능을 향상시키는 몇 가지 방법

파이썬 성능을 향상시키는 몇 가지 솔루션.

1. 함수 호출 최적화(공간 범위, 메모리 액세스 방지)

프로그램 최적화의 핵심은 코드 실행 시간, 메모리 공간 등 연산 범위를 최소화하는 것입니다.

1. 빅데이터 합산, sum 사용

a = range(100000)
%timeit -n 10 sum(a)
10 loops, best of 3: 3.15 ms per loop
%%timeit
  ...: s = 0
  ...: for i in a:
  ...:  s += i
  ...:
100 loops, best of 3: 6.93 ms per loop

2. 작은 데이터를 합칠 때는 sum을 사용하지 마세요

%timeit -n 1000 s = a + b + c + d + e + f + g + h + i + j + k # 数据量较小时直接累加更快
1000 loops, best of 3: 571 ns per loop
%timeit -n 1000 s = sum([a,b,c,d,e,f,g,h,i,j,k]) # 小数据量调用 sum 函数，空间效率降低
1000 loops, best of 3: 669 ns per loop

결론: 빅데이터의 합은 효율이 높고, 스몰데이터의 합은 직접 축적의 효율이 높다.

2. 요소를 가져오기 위한 루프 최적화(메모리 액세스를 방지하려면 스택 또는 레지스터 사용)

for lst in [(1, 2, 3), (4, 5, 6)]: # lst 索引需要额外开销
  pass

인덱스 사용은 최대한 피해야 합니다.

for a, b, c in [(1, 2, 3), (4, 5, 6)]: # better
  pass

각 요소에 직접 값을 할당하는 것과 같습니다.

def force():
 lst = range(4)
 for a1 in [1, 2]:
   for a2 in lst:
     for a3 in lst:
       for b1 in lst:
         for b2 in lst:
           for b3 in lst:
             for c1 in lst:
               for c2 in lst:
                 for c3 in lst:
                   for d1 in lst:
                     yield (a1, a2, a3, b1, b2, b3, c1, c2, c3, d1)
                      
%%timeit -n 10
for t in force():
  sum([t[0], t[1], t[2], t[3], t[4], t[5], t[6], t[7], t[8], t[9]])
10 loops, best of 3: 465 ms per loop
%%timeit -n 10
for a1, a2, a3, b1, b2, b3, c1, c2, c3, d1 in force():
  sum([a1, a2, a3, b1, b2, b3, c1, c2, c3, d1])
10 loops, best of 3: 360 ms per loop

3. 제너레이터 최적화(연산 대신 조회 테이블)

def force(start, end): # 用于密码暴力破解程序
  for i in range(start, end):
    now = i
    sublst = []
    for j in range(10):
      sublst.append(i % 10) # 除法运算开销较大，比乘法大
      i //= 10
    sublst.reverse()
    yield(tuple(sublst), now)

def force(): # better
 lst = range(5)
 for a1 in [1]:
   for a2 in lst:
     for a3 in lst:
       for b1 in lst:
         for b2 in lst:
           for b3 in lst:
             for c1 in lst:
               for c2 in lst:
                 for c3 in lst:
                   for d1 in lst:
                     yield (a1, a2, a3, b1, b2, b3, c1, c2, c3, d1)
　　

r0 = [1, 2] # 可读性与灵活性
r1 = range(10)
r2 = r3 = r4 = r5 = r6 = r7 = r8 = r9 = r1
force = ((a0, a1, a2, a3, a4, a5, a6, a7, a8, a9)
      for a0 in r0 for a1 in r1 for a2 in r2 for a3 in r3 for a4 in r4
      for a5 in r5 for a6 in r6 for a7 in r7 for a8 in r8 for a9 in r9)

4. 전력 운용 최적화(pow(x, y, z))

def isprime(n):
  if n & 1 == 0:
    return False
  k, q = find_kq(n)
  a = randint(1, n - 1)
  if pow(a, q, n) == 1: # 比使用 a ** q % n 运算优化数倍
    return True
  for j in range(k):
    if pow(a, pow(2, j) * q, n) == n - 1: # a **((2 ** j) * q) % n
      return True
  return False

결론: pow(x,y,z)가 x**y%z보다 낫습니다.

5. 부서 운영 최적화

In [1]: from random import getrandbits
 
In [2]: x = getrandbits(4096)
 
In [3]: y = getrandbits(2048)
 
In [4]: %timeit -n 10000 q, r = divmod(x, y)
10000 loops, best of 3: 10.7 us per loop
 
In [5]: %timeit -n 10000 q, r = x//y, x % y
10000 loops, best of 3: 21.2 us per loop

결론: divmod가 // 및 %보다 낫습니다.

6. 최적화 알고리즘의 시간 복잡도

알고리즘의 시간 복잡도는 프로그램의 실행 효율성에 가장 큰 영향을 미칩니다. Python에서는 적절한 데이터 구조를 선택하여 시간 복잡도를 최적화할 수 있습니다. 목록과 집합은 각각 O(n)과 O(1)입니다. 시나리오마다 최적화 방법이 다릅니다. 일반적으로 분할 및 정복, 분기 및 바인딩, 탐욕스러운 동적 프로그래밍과 같은 아이디어가 있습니다.

7. 카피와 딥카피의 합리적인 활용

dict, list 등의 데이터 구조 객체의 경우 직접 할당은 참조를 사용합니다. 전체 개체를 복사해야 하는 경우도 있습니다. 이 경우 복사 패키지에서 복사와 딥카피를 사용할 수 있습니다. 이 두 기능의 차이점은 딥카피가 재귀적으로 복사한다는 것입니다. 효율성이 다릅니다:

In [23]: import copy
In [24]: %timeit -n 10 copy.copy(a)
10 loops, best of 3: 606 ns per loop
In [25]: %timeit -n 10 copy.deepcopy(a)
10 loops, best of 3: 1.17 us per loop

timeit 뒤의 -n은 실행 횟수를 나타냅니다. 마지막 두 줄은 두 timeit의 출력에 해당하며 아래와 같습니다. 후자가 훨씬 더 느리다는 것을 알 수 있습니다.

카피에 대한 예:

>>> lists = [[]] * 3
>>> lists
[[], [], []]
>>> lists[0].append(3)
>>> lists
[[3], [3], [3]]

[[]]는 빈 목록을 포함하는 단일 요소 목록이므로 [[]] * 3의 세 요소는 모두 이 빈 목록을 가리킵니다. 목록의 요소를 수정하면 목록도 수정됩니다. 수정 효율이 높습니다.

8. dict 또는 set을 사용하여 요소 찾기

Python 사전과 세트는 해시 테이블(c 표준 라이브러리 unordered_map과 유사)을 사용하여 구현되며 요소를 찾는 시간 복잡도는 O(1)입니다.

In [1]: r = range(10**7)
In [2]: s = set(r) # 占用 588MB 内存
In [3]: d = dict((i, 1) for i in r) # 占用 716MB 内存
In [4]: %timeit -n 10000 (10**7) - 1 in r
10000 loops, best of 3: 291 ns per loop
In [5]: %timeit -n 10000 (10**7) - 1 in s
10000 loops, best of 3: 121 ns per loop
In [6]: %timeit -n 10000 (10**7) - 1 in d
10000 loops, best of 3: 111 ns per loop

결론: set은 메모리 사용량이 가장 작고 dict는 실행 시간이 가장 짧습니다.

9. 합리적인 사용(제너레이터) 및 생산량(메모리 절약)

In [1]: %timeit -n 10 a = (i for i in range(10**7)) # 生成器通常遍历更高效
10 loops, best of 3: 933 ns per loop
In [2]: %timeit -n 10 a = [i for i in range(10**7)]
10 loops, best of 3: 916 ms per loop
In [1]: %timeit -n 10 for x in (i for i in range(10**7)): pass
10 loops, best of 3: 749 ms per loop
In [2]: %timeit -n 10 for x in [i for i in range(10**7)]: pass
10 loops, best of 3: 1.05 s per loop

결론: 제너레이터를 사용해 횡단해 보세요.

위 내용은 Python 성능을 향상하기 위한 몇 가지 솔루션입니다. 필요한 경우 계속해서 추가할 예정입니다.