Farih.co.id
Home Programming Cara Mengelola Sumber Daya dengan Python Dengan Manajer Konteks

Cara Mengelola Sumber Daya dengan Python Dengan Manajer Konteks

Sangat penting untuk mengelola sumber daya dengan benar saat membangun aplikasi untuk mencegah kebocoran memori, memastikan pembersihan yang tepat, dan menjaga stabilitas aplikasi Anda. Manajer konteks menawarkan solusi yang tepat untuk situasi ini. Manajer konteks menyederhanakan pengelolaan sumber daya dengan mengotomatiskan proses perolehan dan pelepasan sumber daya.


VIDEO MUO HARI INI

GULIR UNTUK MELANJUTKAN ISI

Apa Itu Manajer Konteks?

Manajer konteks, pada intinya, adalah objek yang mendefinisikan metode perolehan dan pelepasan sumber daya sesuai kebutuhan. Manajer konteks sangat membantu karena mereka dapat mengatur pengelolaan sumber daya ke dalam struktur yang jelas, sederhana, dan ringkas. Menggunakan pengelola konteks dapat mengurangi duplikasi kode dan membuat kode Anda lebih mudah dibaca.

Bayangkan sebuah program yang harus mencatat data dalam sebuah file. Kapan pun aplikasi Anda perlu mencatat sesuatu, Anda harus membuka dan menutup file log secara manual karena tidak ada pengelola konteks. Namun, dengan menggunakan manajer konteks, Anda menyederhanakan penyiapan dan dekonstruksi sumber daya logging, sehingga menjamin penanganan tugas logging yang tepat.

Pernyataan dengan

Itu dengan pernyataan dengan Python menyediakan cara untuk menggunakan pengelola konteks. Sekalipun pengecualian terjadi saat blok kode dijalankan, hal ini memastikan bahwa sumber daya yang diperoleh dilepaskan dengan tepat setelah digunakan sebagaimana mestinya.

 with context_manager_expression as resource:
    

Dengan memanfaatkan dengan pernyataan, Anda memberi manajer konteks kendali atas manajemen sumber daya, sehingga membebaskan perhatian Anda untuk berkonsentrasi pada logika aplikasi Anda.

Menggunakan Manajer Konteks Bawaan

Python menawarkan pengelola konteks bawaan untuk skenario umum. Anda akan melihat dua contoh: penanganan file menggunakan membuka() fungsi dan mengelola koneksi jaringan menggunakan stopkontak modul.

Penanganan File Dengan open()

Itu membuka() fungsi adalah manajer konteks bawaan yang digunakan untuk bekerja dengan file. Ini sering digunakan untuk membaca atau menulis ke file dan mengembalikan objek file. Saat Anda menggunakan manajer konteks untuk mengelola file, ini menghindari potensi kerusakan data dengan menutup file secara otomatis ketika tidak lagi diperlukan.

 with open('file.txt', 'r') as file:
    content = file.read()
    

Koneksi Jaringan Dengan soket()

Itu stopkontak modul menyediakan manajer konteks untuk soket jaringan. Manajer konteks dapat memastikan pengaturan dan pembongkaran yang tepat saat bekerja dengan koneksi jaringan, sehingga mencegah kerentanan koneksi.

 import socket

with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.connect(('localhost', 8080))
    

Menerapkan Manajer Konteks Kustom

Pengelola konteks khusus memungkinkan Anda merangkum pengelolaan sumber daya atau perilaku tertentu dalam kode Anda. Python menyediakan cara berbeda untuk membuat pengelola konteks khusus, masing-masing disesuaikan dengan skenario berbeda. Di sini, Anda akan menjelajahi pendekatan berbasis kelas dan berbasis fungsi.

Manajer Konteks Menggunakan Pendekatan Berbasis Kelas

Dalam pendekatan berbasis kelas, Anda mendefinisikan kelas yang mengimplementasikan __memasuki__ Dan __KELUAR__ metode sihir atau bodoh. Itu __memasuki__ metode menginisialisasi dan mengembalikan sumber daya yang ingin Anda kelola, sedangkan __KELUAR__ metode memastikan pembersihan yang tepat, bahkan dengan adanya pengecualian.

 class CustomContext:
    def __enter__(self):
        
        return resource

    def __exit__(self, exc_type, exc_value, traceback):
        
        pass

Pertimbangkan tugas di mana Anda harus menjalankan beberapa proses. Tugas ini memerlukan manajer konteks yang akan menyederhanakan eksekusi semua proses secara bersamaan. Ini juga akan mengotomatiskan pembuatan, eksekusi, dan penggabungan semua proses, menyediakan manajemen sumber daya yang benar, sinkronisasi, dan manajemen kesalahan.

 import multiprocessing
import queue

class ProcessPool:
    def __init__(self, num_processes):
        self.num_processes = num_processes
        self.processes = []

    def __enter__(self):
        self.queue = multiprocessing.Queue()

        for _ in range(self.num_processes):
            process = multiprocessing.Process(target=self._worker)
            self.processes.append(process)
            process.start()

        return self

    def __exit__(self, exc_type, exc_value, traceback):
        for process in self.processes:
            
            self.queue.put(None)
        for process in self.processes:
            process.join()

    def _worker(self):
        while True:
            number = self.queue.get()
            if number is None:
                break
            calculate_square(number)

def calculate_square(number):
    result = number * number
    print(f"The square of {number} is {result}")

if __name__ == "__main__":
    numbers = [1, 2, 3, 4, 5]

    
    with ProcessPool(3) as pool:
        for num in numbers:
            pool.queue.put(num)

    
    

Itu Kolam Proses manajer konteks mengelola kumpulan proses pekerja, mendistribusikan tugas (menghitung kuadrat angka) ke proses-proses ini untuk eksekusi bersamaan. Paralelisme ini dapat menghasilkan pemanfaatan inti CPU yang tersedia secara lebih efisien dan berpotensi mempercepat pelaksanaan tugas dibandingkan menjalankannya secara berurutan dalam satu proses.

keluaran dari manajer konteks berbasis kelas

Manajer Konteks Menggunakan Pendekatan Berbasis Fungsi

Itu kontekslib modul menyediakan @contextmanager dekorator untuk membuat pengelola konteks menggunakan fungsi generator. Dekorator memungkinkan Anda menambahkan fungsionalitas ke suatu fungsi tanpa mengubahnya.

Dalam fungsi generator yang dihias, Anda dapat menggunakan menghasilkan Dan terakhir pernyataan untuk menunjukkan di mana sumber daya diperoleh dan di mana sumber daya tersebut harus dilepaskan.

 from contextlib import contextmanager

@contextmanager
def custom_context():
    
    resource = ...

    try:
        yield resource
    finally:
        
        pass

Katakanlah Anda ingin mengembangkan manajer konteks yang menghitung berapa lama waktu yang diperlukan untuk mengeksekusi blok kode. Anda dapat melakukan ini dengan menggunakan strategi berbasis fungsi.

 import time
from contextlib import contextmanager

@contextmanager
def timing_context():
    start_time = time.time()

    try:
        yield
    finally:
        end_time = time.time()
        elapsed_time = end_time - start_time
        print(f"Elapsed time: {elapsed_time} seconds")


with timing_context():
    
    time.sleep(2)

Dalam contoh ini, waktu_konteks manajer konteks mencatat waktu mulai dan berakhirnya blok kode dan menghitung waktu yang telah berlalu ketika blok tersebut keluar.

keluaran dari manajer konteks berbasis fungsi

Dengan menggunakan pendekatan mana pun, Anda dapat membangun pengelola konteks khusus untuk merangkum logika manajemen sumber daya yang rumit dan operasi berulang, sehingga meningkatkan pengorganisasian dan kemampuan pemeliharaan kode Anda.

Manajer Konteks Bersarang

Pengelola konteks bertingkat bermanfaat ketika menghadapi situasi yang menuntut kendali beberapa sumber daya. Anda dapat mempertahankan alur kerja yang jelas dan bebas kesalahan dengan menyusun konteks dan memastikan semua sumber daya diperoleh dan dilepaskan dengan benar.

Pertimbangkan situasi di mana program Anda harus membaca data dari sebuah file dan memasukkannya ke dalam database. Dalam situasi ini, Anda harus mengelola dua sumber daya terpisah: file dan koneksi database. Penyusunan manajer konteks dapat memfasilitasi proses ini:

 import sqlite3

class DatabaseConnection:
    def __enter__(self):
        self.connection = sqlite3.connect('lite.db')
        return self.connection

    def __exit__(self, exc_type, exc_value, traceback):
        self.connection.close()


with DatabaseConnection() as db_conn, open('data.txt', 'r') as file:
    cursor = db_conn.cursor()

    
    cursor.execute("CREATE TABLE IF NOT EXISTS data_table (data TEXT)")

    
    for line in file:
        data = line.strip()
        cursor.execute("INSERT INTO data_table (data) VALUES (?)", (data,))

    db_conn.commit()

Dalam contoh ini, Koneksi Basis Data manajer konteks menangani koneksi database, sedangkan yang built-in membuka() manajer konteks menangani file tersebut.

Anda memastikan file dan koneksi database dikelola dengan tepat dengan menyarangkan dua konteks dalam satu pernyataan. Kedua sumber daya akan dilepaskan dengan benar jika terjadi pengecualian selama pembacaan file atau penyisipan database.

Menyesuaikan Fungsi Dengan Dekorator

Pengelolaan sumber daya yang efektif merupakan persyaratan penting. Kebocoran sumber daya dapat menyebabkan memori membengkak, ketidakstabilan sistem, dan bahkan kelemahan keamanan. Anda telah melihat bagaimana pengelola konteks menawarkan solusi elegan terhadap masalah pengelolaan sumber daya.

Comment
Share:

Leave a Reply

Your email address will not be published. Required fields are marked *

beli jitu https://167.71.217.241/ https://188.166.210.27/ https://103.253.147.8/ https://139.59.194.132/ https://152.42.192.54/ https://152.42.187.123/ https://188.166.196.248/ https://163.47.9.78/ https://157.230.245.144/ http://68.183.96.87/ http://147.182.210.122/ http://147.182.128.234/ http://167.172.1.184/ http://157.245.5.74/ http://139.59.217.59/ http://163.47.9.16/ http://144.126.251.215/ http://139.59.217.128/ http://103.186.0.254/ http://161.35.251.176/ http://157.245.29.71/ https://170.64.254.102/ https://www.markas303.ac.id/ https://www.markas303.or.id/ https://www.markas303.sch.id/ http://103.172.205.75/ http://103.245.38.119/ http://138.197.224.231/ http://138.197.224.231/

Ad