0Pricing
Python Academy · Lekcja

Praktyczne wzorce menedżerów kontekstu

Proszę stosować menedżery kontekstu do plików, blokad, liczników czasu i połączeń z bazą danych.

Praktyczne wzorce menedżerów kontekstu to bezpłatna lekcja Python Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Python Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Python Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Menedżery kontekstu elegancko rozwiązują rzeczywiste problemy związane z zarządzaniem zasobami, takimi jak pliki, bazy danych, blokady, czasomierze i inne.

Potok przetwarzania plików

Otwórz jednocześnie pliki wejściowy i wyjściowy, przetwarzaj je wiersz po wierszu i zamknij oba automatycznie.
import io
src = io.StringIO('line1\nline2\nline3')
dst = io.StringIO()
with src, dst:
    for line in src:
        dst.write(line.upper())
print(dst.getvalue())

Transakcja bazy danych

Umieść operacje na bazie danych w menedżerze kontekstu: zatwierdź je w przypadku powodzenia, wycofaj w przypadku wyjątku i zawsze zamknij połączenie.
from contextlib import contextmanager
@contextmanager
def db_transaction(conn):
    try:
        yield conn
        print('COMMIT')
    except Exception as e:
        print(f'ROLLBACK: {e}')
        raise
    finally:
        print('CLOSE')
with db_transaction({'execute': lambda q: print(f'SQL: {q}')}) as db:
    db['execute']('INSERT ...')

Blokada wątków

with lock: pobiera blokadę, wykonuje treść bloku i zwalnia blokadę przy wychodzeniu — nie trzeba ręcznie wywoływać acquire/release.
import threading
lock = threading.Lock()
shared = []
def add(x):
    with lock:
        shared.append(x)
add(1); add(2)
print(shared)

Zmiana katalogu

os.chdir() globalnie zmienia bieżący katalog roboczy. Menedżer kontekstu zapisuje go i przywraca.
from contextlib import contextmanager
import os
@contextmanager
def chdir(path):
    old = os.getcwd()
    os.chdir(path)
    try: yield
    finally: os.chdir(old)
original = os.getcwd()
with chdir('/tmp'):
    print('in tmp:', os.getcwd())
print('back:', os.getcwd())

Pliki tymczasowe

tempfile.NamedTemporaryFile jako menedżer kontekstu automatycznie tworzy i usuwa plik tymczasowy.
import tempfile
with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=True) as f:
    f.write('temp data')
    print('temp file:', f.name)
print('deleted')

Tymczasowa zmiana zmiennej środowiskowej

Tymczasowo ustaw zmienną środowiskową na potrzeby testu lub procesu podrzędnego, a następnie ją przywróć.
from contextlib import contextmanager
import os
@contextmanager
def env(**kwargs):
    old = {k: os.environ.get(k) for k in kwargs}
    os.environ.update({k:str(v) for k,v in kwargs.items()})
    try: yield
    finally:
        for k,v in old.items():
            if v is None: os.environ.pop(k,None)
            else: os.environ[k]=v
with env(DEBUG='1', LOG_LEVEL='DEBUG'):
    print(os.environ['DEBUG'])

Blok profilowania

Owiń blok za pomocą cProfile, aby zmierzyć jego wydajność wewnątrz menedżera kontekstu.
from contextlib import contextmanager
import cProfile
@contextmanager
def profile():
    pr = cProfile.Profile()
    pr.enable()
    yield pr
    pr.disable()
with profile() as pr:
    sum(range(1000000))
print('profiled')

Gniazdo sieciowe

Gniazda implementują protokół menedżera kontekstu: with socket.socket() as s: zamyka gniazdo przy wychodzeniu z kontekstu.
import socket
try:
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        s.settimeout(0.1)
        print('socket ready')
except Exception as e:
    print(f'socket: {e}')

Przechwytywanie ostrzeżeń

warnings.catch_warnings() przechwytuje ostrzeżenia emitowane wewnątrz bloku, co jest przydatne w testach.
import warnings
with warnings.catch_warnings(record=True) as w:
    warnings.simplefilter('always')
    warnings.warn('test warning')
print(len(w), w[0].category.__name__)

Łączenie wzorców

Menedżery kontekstu w rzeczywistych zastosowaniach często łączą wiele wzorców: transakcję, rejestrowanie i pomiar czasu w jednym wielokrotnego użytku komponencie.
from contextlib import contextmanager
import time
@contextmanager
def timed_operation(name):
    print(f'[{name}] start')
    t0 = time.perf_counter()
    try:
        yield
        print(f'[{name}] done in {time.perf_counter()-t0:.4f}s')
    except Exception as e:
        print(f'[{name}] failed: {e}')
        raise
with timed_operation('loop'):
    sum(range(100000))

Szybki test

Który mechanizm obsługi wątków implementuje protokół menedżera kontekstu, zapewniając bezpieczny dostęp współbieżny?

Podsumowanie

Wzorce menedżerów kontekstu: potoki plików, transakcje baz danych, blokady, zmiany katalogów, pliki tymczasowe, zmienne środowiskowe i profilowanie. Użyj ExitStack do dynamicznych stosów zasobów.

Działaj dalej

Świetna praca! Czeka na Ciebie następna lekcja.

Często zadawane pytania

Czy lekcja „Praktyczne wzorce menedżerów kontekstu” jest bezpłatna?

Tak — pełny tekst „Praktyczne wzorce menedżerów kontekstu” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Python Academy, przejdź na CoddyKit PRO. Kurs Python Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Praktyczne wzorce menedżerów kontekstu”?

Proszę stosować menedżery kontekstu do plików, blokad, liczników czasu i połączeń z bazą danych. Ćwiczysz Python Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Python Academy?

Nie wymagamy żadnego doświadczenia. Python Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Praktyczne wzorce menedżerów kontekstu”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Python Academy?

Tak. Każda lekcja Python Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Instrukcja with — szczegółowe omówienie
  2. Protokół __enter__ i __exit__
  3. contextlib: @contextmanager
  4. Praktyczne wzorce menedżerów kontekstu
← Powrót do Python Academy