Teknik Python untuk Pengurusan Memori yang Cekap-Tutorial Python-php.cn

owerful Python Techniques for Efficient Memory Management

Sebagai pengarang terlaris, saya menjemput anda untuk menerokai buku saya di Amazon. Jangan lupa ikuti saya di Medium dan tunjukkan sokongan anda. terima kasih! Sokongan anda bermakna dunia!

Pengurusan memori Python ialah aspek kritikal untuk membangunkan aplikasi yang cekap dan berskala. Sebagai pembangun, saya mendapati bahawa menguasai teknik ini boleh meningkatkan prestasi tugasan intensif memori dengan ketara. Mari kita terokai enam teknik Python yang berkuasa untuk pengurusan ingatan yang cekap.

Pengumpulan objek ialah strategi yang sering saya gunakan untuk meminimumkan overhed peruntukan dan deallokasi. Dengan menggunakan semula objek dan bukannya mencipta yang baharu, kami boleh mengurangkan pergolakan memori dan meningkatkan prestasi. Berikut ialah pelaksanaan ringkas kumpulan objek:

class ObjectPool:
    def __init__(self, create_func):
        self.create_func = create_func
        self.pool = []

    def acquire(self):
        if self.pool:
            return self.pool.pop()
        return self.create_func()

    def release(self, obj):
        self.pool.append(obj)

def create_expensive_object():
    return [0] * 1000000

pool = ObjectPool(create_expensive_object)

obj1 = pool.acquire()
# Use obj1
pool.release(obj1)

obj2 = pool.acquire()  # This will reuse the same object

Salin selepas log masuk

Teknik ini amat berguna untuk objek yang mahal untuk dibuat atau sering digunakan dan dibuang.

Rujukan yang lemah ialah satu lagi alat yang berkuasa dalam senjata pengurusan memori Python. Mereka membenarkan kami membuat pautan ke objek tanpa meningkatkan kiraan rujukannya, yang boleh berguna untuk melaksanakan cache atau mengelakkan rujukan bulat. Modul weakref menyediakan fungsi yang diperlukan:

import weakref

class ExpensiveObject:
    def __init__(self, value):
        self.value = value

def on_delete(ref):
    print("Object deleted")

obj = ExpensiveObject(42)
weak_ref = weakref.ref(obj, on_delete)

print(weak_ref().value)  # Output: 42
del obj
print(weak_ref())  # Output: None (and "Object deleted" is printed)

Salin selepas log masuk

Menggunakan slot dalam kelas boleh mengurangkan penggunaan memori dengan ketara, terutamanya apabila berhadapan dengan banyak kejadian. Dengan mentakrifkan slot, kami memberitahu Python untuk menggunakan tatasusunan saiz tetap untuk atribut dan bukannya kamus dinamik:

class RegularClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class SlottedClass:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

import sys

regular = RegularClass(1, 2)
slotted = SlottedClass(1, 2)

print(sys.getsizeof(regular))  # Output: 48 (on Python 3.8, 64-bit)
print(sys.getsizeof(slotted))  # Output: 24 (on Python 3.8, 64-bit)

Salin selepas log masuk

Fail yang dipetakan memori ialah teknik yang berkuasa untuk mengendalikan set data yang besar dengan cekap. Modul mmap membolehkan kami memetakan fail terus ke dalam memori, menyediakan akses rawak pantas tanpa memuatkan keseluruhan fail:

import mmap

with open('large_file.bin', 'rb') as f:
    mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
    # Read 100 bytes starting at offset 1000
    data = mm[1000:1100]
    mm.close()

Salin selepas log masuk

Pendekatan ini amat berguna apabila bekerja dengan fail yang terlalu besar untuk dimuatkan ke dalam ingatan.

Mengenal pasti objek yang haus memori adalah penting untuk mengoptimumkan penggunaan memori. Fungsi sys.getsizeof() menyediakan titik permulaan, tetapi ia tidak mengambil kira objek bersarang. Untuk pemprofilan memori yang lebih komprehensif, saya sering menggunakan alatan pihak ketiga seperti memory_profiler:

from memory_profiler import profile

@profile
def memory_hungry_function():
    list_of_lists = [[i] * 1000 for i in range(1000)]
    return sum(sum(sublist) for sublist in list_of_lists)

memory_hungry_function()

Salin selepas log masuk

Ini akan mengeluarkan laporan penggunaan memori baris demi baris, membantu mengenal pasti bahagian kod anda yang paling intensif memori.

Mengurus koleksi besar dengan cekap adalah penting untuk aplikasi intensif memori. Apabila berurusan dengan set data yang besar, saya sering menggunakan penjana dan bukannya senarai untuk memproses data secara berperingkat:

def process_large_dataset(filename):
    with open(filename, 'r') as f:
        for line in f:
            yield process_line(line)

for result in process_large_dataset('large_file.txt'):
    print(result)

Salin selepas log masuk

Pendekatan ini membolehkan kami memproses data tanpa memuatkan keseluruhan set data ke dalam memori sekaligus.

Skim pengurusan memori tersuai boleh dilaksanakan untuk kes penggunaan tertentu. Sebagai contoh, kita boleh mencipta objek seperti senarai tersuai yang menulis secara automatik ke cakera apabila ia membesar terlalu besar:

class ObjectPool:
    def __init__(self, create_func):
        self.create_func = create_func
        self.pool = []

    def acquire(self):
        if self.pool:
            return self.pool.pop()
        return self.create_func()

    def release(self, obj):
        self.pool.append(obj)

def create_expensive_object():
    return [0] * 1000000

pool = ObjectPool(create_expensive_object)

obj1 = pool.acquire()
# Use obj1
pool.release(obj1)

obj2 = pool.acquire()  # This will reuse the same object

Salin selepas log masuk

Kelas ini membolehkan kami bekerja dengan senarai yang lebih besar daripada memori yang tersedia dengan memunggah data secara automatik ke cakera.

Apabila bekerja dengan tatasusunan NumPy, yang biasa digunakan dalam pengkomputeran saintifik, kami boleh menggunakan tatasusunan dipetakan memori untuk pengendalian set data besar yang cekap:

import weakref

class ExpensiveObject:
    def __init__(self, value):
        self.value = value

def on_delete(ref):
    print("Object deleted")

obj = ExpensiveObject(42)
weak_ref = weakref.ref(obj, on_delete)

print(weak_ref().value)  # Output: 42
del obj
print(weak_ref())  # Output: None (and "Object deleted" is printed)

Salin selepas log masuk

Pendekatan ini membolehkan kami bekerja dengan tatasusunan yang lebih besar daripada RAM yang tersedia, dengan perubahan disegerakkan secara automatik ke cakera.

Untuk aplikasi pelayan yang berjalan lama, melaksanakan cache objek tersuai boleh meningkatkan prestasi dengan ketara dan mengurangkan penggunaan memori:

class RegularClass:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class SlottedClass:
    __slots__ = ['x', 'y']
    def __init__(self, x, y):
        self.x = x
        self.y = y

import sys

regular = RegularClass(1, 2)
slotted = SlottedClass(1, 2)

print(sys.getsizeof(regular))  # Output: 48 (on Python 3.8, 64-bit)
print(sys.getsizeof(slotted))  # Output: 24 (on Python 3.8, 64-bit)

Salin selepas log masuk

Cache ini tamat tempoh entri secara automatik selepas masa yang ditetapkan, menghalang kebocoran memori dalam aplikasi yang berjalan lama.

Apabila berurusan dengan tugas pemprosesan teks yang besar, menggunakan iterator dan penjana boleh mengurangkan penggunaan memori dengan ketara:

import mmap

with open('large_file.bin', 'rb') as f:
    mm = mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ)
    # Read 100 bytes starting at offset 1000
    data = mm[1000:1100]
    mm.close()

Salin selepas log masuk

Pendekatan ini memproses fail baris demi baris, mengelakkan keperluan untuk memuatkan keseluruhan fail ke dalam memori.

Untuk aplikasi yang mencipta banyak objek sementara, menggunakan pengurus konteks boleh memastikan pembersihan yang betul dan mengelakkan kebocoran memori:

from memory_profiler import profile

@profile
def memory_hungry_function():
    list_of_lists = [[i] * 1000 for i in range(1000)]
    return sum(sum(sublist) for sublist in list_of_lists)

memory_hungry_function()

Salin selepas log masuk

Corak ini memastikan sumber dikeluarkan dengan betul, walaupun pengecualian berlaku.

Apabila bekerja dengan set data besar dalam panda, kami boleh menggunakan chunking untuk memproses data dalam bahagian yang boleh diurus:

def process_large_dataset(filename):
    with open(filename, 'r') as f:
        for line in f:
            yield process_line(line)

for result in process_large_dataset('large_file.txt'):
    print(result)

Salin selepas log masuk

Pendekatan ini membolehkan kami bekerja dengan set data yang lebih besar daripada memori yang tersedia dengan memprosesnya dalam ketulan.

Kesimpulannya, pengurusan memori yang cekap dalam Python melibatkan gabungan ciri bahasa terbina dalam, alatan pihak ketiga dan pelaksanaan tersuai. Dengan menggunakan teknik ini dengan bijak, kami boleh mencipta aplikasi Python yang cekap memori dan berprestasi, walaupun ketika berurusan dengan set data yang besar atau proses yang berjalan lama. Perkara utama ialah memahami ciri memori aplikasi kami dan memilih teknik yang sesuai untuk setiap kes penggunaan tertentu.

101 Buku

101 Buku ialah syarikat penerbitan dipacu AI yang diasaskan bersama oleh pengarang Aarav Joshi. Dengan memanfaatkan teknologi AI termaju, kami memastikan kos penerbitan kami sangat rendah—sesetengah buku berharga serendah $4—menjadikan pengetahuan berkualiti boleh diakses oleh semua orang.

Lihat buku kami Kod Bersih Golang tersedia di Amazon.

Nantikan kemas kini dan berita menarik. Apabila membeli-belah untuk buku, cari Aarav Joshi untuk mencari lebih banyak tajuk kami. Gunakan pautan yang disediakan untuk menikmati diskaun istimewa!

Ciptaan Kami

Pastikan anda melihat ciptaan kami:

Kami berada di Medium

Atas ialah kandungan terperinci Teknik Python untuk Pengurusan Memori yang Cekap. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!