9 Tips Hebat Untuk Meningkatkan Performa Code Python Anda

Python ialah bahasa pemrograman populer yang dikenal karena kemudahan penggunaan dan keterbacaannya. Tetapi, terkadang dapat semakin lambat dari bahasa lain karena karakternya yang ditafsirkan. Untungnya, ada beberapa cara untuk memaksimalkan code Python Anda dan membuat lebih cepat tanpa mengorbankan keterbacaan dan pemeliharaan.

Berikut adalah beberapa tip yang bisa membantu Anda memaksimalkan code python Anda.

Gunakan fungsi dan pustaka bawaan :

Python menyediakan beragam fungsi dan pustaka bawaan yang dimaksimalkan untuk kinerja. Misalnya, gunakan map() atau daftar pemahaman alih-alih for loop, dan pakai numpy atau pandas untuk manipulasi array dan data.

# Using list comprehension instead of for loop
squares = [x**2 for x in range(1000)]

# Using numpy for array manipulation
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = np.dot(a, b)

Hindari perhitungan yang tidak perlu

Hindari melakukan perhitungan atau operasi yang tidak perlu yang bisa disederhanakan. Misalnya, hindari menghitung nilai yang sama beberapa kali atau melakukan operasi yang serupa pada data yang sama beberapa kali.

# Compute a value only once
x = 5
y = x**2

# Avoid computing the same value multiple times
for i in range(len(my_list)):
    if my_list[i] == x**2:
        # do something

# Perform the same operation only once
result = 2 * x + 3 * x

Gunakan susunan data yang efektif

Gunakan susunan data yang efektif untuk pekerjaan yang ada. Misalnya, pakai kumpulan untuk pengetesan keanggotaan, kamus untuk penelusuran cepat, dan tupel untuk data yang tidak dapat diganti.

# Using sets for membership testing
my_set = set([1, 2, 3])
if 4 in my_set:
    # do something

# Using dictionaries for fast lookups
my_dict = {'a': 1, 'b': 2, 'c': 3}
if 'a' in my_dict:
    # do something

# Using tuples for immutable data
my_tuple = (1, 2, 3)

Gunakan generator dan iterator

Gunakan generator dan iterator alih-alih daftar jika memungkinkannya. Generator dan iterator lebih hemat memory dan bisa lebih cepat dibanding daftar.

# Using a generator instead of a list
my_gen = (x**2 for x in range(1000))

# Using an iterator instead of a list
my_iter = iter(my_list)

Hindari faktor global

Hindari memakai faktor global sebanyak mungkin. Faktor global lebih lambat dan kurang hemat memory dibanding faktor lokal.

# Bad: using global variables
x = 10

def my_function():
    global x
    x += 1

# Good: using local variables
def my_function(x):
    x += 1
    return x

Gunakan cache

Gunakan caching untuk menghindari menghitung nilai yang serupa berkali-kali. Gunakan memoization atau dekorator lru_cache untuk meng-cache hasil perhitungan yang mahal.

# Using memoization
cache = {}

def my_function(x):
    if x in cache:
        return cache[x]
    else:
        result = expensive_computation(x)
        cache[x] = result
        return result

# Using the lru_cache decorator
from functools import lru_cache

@lru_cache(maxsize=None)
def my_function(x):
    result = expensive_computation(x)
    return result

Gunakan paralelisasi

Gunakan paralelisasi untuk mempercepat komputasi. Gunakan modul multiprocessing atau concurrent.futures untuk menjalankan banyak pekerjaan secara paralel.

# Using multiprocessing
from multiprocessing import Pool

def my_function(x):
    # do something

with Pool() as pool:
    results = pool.map(my_function

Hindari pemakaian memory yang terlalu berlebih

Hindari memakai terlalu banyak memory dengan meminimalkan ukuran susunan data dan melepaskan memory yang tidak kepakai. Gunakan generator atau pernyataan yield untuk mengalirkan data alih-alih memuat semuanya ke memory sekaligus.

# Using generators to stream data
def read_data(filename):
    with open(filename) as f:
        for line in f:
            yield line

# Releasing unused memory
my_list = [1, 2, 3]
del my_list[0]

Gunakan Cython atau Numba

Gunakan Cython atau Numba untuk mengoptimalkan bagian code Anda yang intens komputasi. Cython ialah kompiler statis yang bisa mengubah code Python menjadi code C cepat, dan Numba ialah kompiler just-in-time (JIT) yang bisa mengkompilasi code Python ke code mesin.

# Using Cython to optimize code
%load_ext cython

%%cython
def my_function():
    # do something

# Using Numba to optimize code
from numba import jit

@jit
def my_function():
    # do something

Selesai

Penting untuk ditulis jika pengoptimalan harus dilaksanakan hati-hati dan hanya bila dibutuhkan. Penting untuk menyeimbangkan kinerja dengan keterbacaan dan pemeliharaan. Selain itu, perlu diingat bahwa optimalisasi yang terlalu dini bisa mengakibatkan code yang lebih sulit dimengerti dan dipelihara.