Cara menggunakan ungkapan biasa Python untuk menghafal kod

Dalam Python, ungkapan biasa ialah alat pemprosesan teks yang sangat berkuasa. Ia boleh digunakan untuk memadankan dan menggantikan format tertentu dalam teks, menjadikan pemprosesan teks lebih cekap dan mudah.

Apabila menulis kod berskala besar, kita sering menghadapi situasi di mana penghafalan diperlukan. Hafalan merujuk kepada caching hasil yang dijana semasa pelaksanaan fungsi supaya hasil cache boleh digunakan terus dalam panggilan berikutnya, dengan itu mengelakkan pengiraan berulang dan meningkatkan kecekapan pelaksanaan kod. Dalam Python, kami boleh menggunakan penghias untuk melaksanakan fungsi hafalan dan ungkapan biasa boleh membantu kami mengurus cache hafalan dengan lebih baik.

Artikel ini akan memperkenalkan cara menggunakan ungkapan biasa Python untuk menghafal kod. Pertama, kita perlu memahami penggunaan asas penghias.

1. Asas Penghias

Penghias ialah struktur sintaks yang boleh menambah fungsi tambahan pada fungsi tanpa mengubah kod fungsi. Ia biasanya fungsi yang mengambil fungsi yang dihias sebagai parameter, dan nilai pulangannya ialah fungsi baharu ini secara automatik akan melakukan beberapa operasi tambahan apabila fungsi yang dihias dipanggil.

Berikut ialah contoh penghias mudah yang boleh mengira masa pelaksanaan fungsi:

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print('Function "{}" takes {}s to execute.'.format(func.__name__, end_time - start_time))
        return result
    return wrapper

@timer
def foo():
    time.sleep(1)
    return 'Done'

foo()

Dalam kod di atas, pemasa penghias ditakrifkan, yang menerima fungsi sebagai parameter dan mengembalikan fungsi baharu pembalut. Apabila fungsi pembungkus melaksanakan fungsi yang dihias, ia mula-mula mengira masa pelaksanaan fungsi, kemudian mengeluarkan masa pelaksanaan, dan akhirnya mengembalikan hasil pelaksanaan fungsi yang dihias.

Apabila menggunakan penghias, anda hanya perlu menambah sintaks nama @decorator sebelum fungsi yang dihias.

2. Pelaksanaan hafalan

Di bawah ini kami akan memperkenalkan cara menggunakan penghias untuk melaksanakan fungsi hafalan. Khususnya, kami mahu dapat men-cache parameter input dan hasil output fungsi supaya panggilan seterusnya boleh menggunakan hasil cache secara langsung tanpa pengiraan semula. Untuk mencapai fungsi ini, kita boleh menggunakan struktur data khas dalam Python - kamus. Kami menggunakan parameter input fungsi sebagai kunci kamus, hasil output fungsi sebagai nilai kamus, dan menyimpannya dalam pembolehubah global. Setiap kali fungsi yang dihias dipanggil, mula-mula semak sama ada hasil keluaran yang sepadan telah wujud dalam kamus Jika ia wujud, hasil cache akan dikembalikan secara langsung .

Berikut ialah contoh penghias memoize yang mudah:

import functools

memory = {}

def memoize(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        key = (args, tuple(kwargs.items()))
        if key not in memory:
            memory[key] = func(*args, **kwargs)
        return memory[key]
    return wrapper

@memoize
def add(x, y):
    print('Adding {} and {}...'.format(x, y))
    return x + y

print(add(2, 3))    # Adding 2 and 3... 5
print(add(2, 3))    # 5

Dalam kod di atas, penghias memoize ditakrifkan, fungsinya adalah untuk menyimpan pasangan nilai kunci cache dalam memori pembolehubah global kepada semak kehadiran hasil cache pada panggilan berikutnya. Apabila fungsi yang dihias dipanggil, parameter input mula-mula ditukar menjadi tupel dan kamus, dan kemudian digunakan sebagai pasangan nilai kunci untuk mencari sama ada terdapat hasil cache. Jika ia tidak wujud, fungsi yang dihias dipanggil untuk mengira hasil dan hasilnya ditambahkan pada kamus cache. Jika ia wujud, hasil cache dikembalikan secara langsung. Untuk fungsi yang dihias, kami menggunakan functools.wraps untuk melaksanakan docstring dan pewarisan nama fungsi.

Kod di atas sesuai untuk menggunakan jenis data biasa sebagai parameter input fungsi, tetapi dalam pembangunan sebenar, kita mungkin menghadapi jenis data yang lebih kompleks, seperti senarai, tupel, set, dsb. Pada ketika ini, kita perlu menggunakan ungkapan biasa untuk menukar jenis data kepada rentetan supaya ia boleh digunakan sebagai kunci untuk caching pasangan nilai kunci.

3. Penggunaan ungkapan biasa

Ungkapan biasa ialah ungkapan yang boleh digunakan untuk memadankan dan memproses rentetan. Dalam Python, kita boleh menggunakan ungkapan biasa menggunakan modul semula. Berikut ialah contoh ungkapan biasa yang mudah:

import re

pattern = r'd+'
text = '123abc456def789'
match = re.search(pattern, text)
print(match.group())    # 123

Dalam kod di atas, kami mentakrifkan corak ungkapan biasa yang mengandungi d+, yang bermaksud memadankan satu atau lebih nombor. Kemudian kami menggunakan fungsi re.search untuk memadankan corak dalam teks rentetan dan mengembalikan objek Padanan. Objek Padanan mengandungi maklumat seperti rentetan yang dipadankan, kedudukan mula dan tamat, dsb. Kita boleh mendapatkan rentetan yang dipadankan melalui kaedah kumpulan.

Apabila melaksanakan fungsi memoisasi, kami boleh menukar parameter input ke dalam rentetan dan menggunakan ungkapan biasa untuk mengekstrak nombor, huruf, simbol dan maklumat lain dalam parameter sebagai kunci untuk menyimpan pasangan nilai kunci. Berikut ialah contoh kod:

import re
import functools

memory = {}

def memoize(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        args_str = ', '.join(map(str, args))
        kwargs_str = ', '.join('{}={}'.format(k, v) for k, v in kwargs.items())
        key_str = args_str + ', ' + kwargs_str
        match = re.search(r'd+', key_str)
        key = match.group()
        if key not in memory:
            memory[key] = func(*args, **kwargs)
        return memory[key]
    return wrapper

@memoize
def add(x, y):
    print('Adding {} and {}...'.format(x, y))
    return x + y

print(add(2, 3))    # Adding 2 and 3... 5
print(add(2, 3))    # 5

print(add(2, 4))    # Adding 2 and 4... 6
print(add(2, 4))    # 6

print(add(1, y=2))  # Adding 1 and 2... 3
print(add(1, y=2))  # 3

Dalam kod di atas, kami menukar parameter input kepada rentetan dan menggunakan ungkapan biasa untuk mengekstrak nombor daripadanya sebagai kunci untuk pasangan nilai kunci. Jika kunci yang sepadan sudah wujud dalam kamus cache, hasilnya dikembalikan secara langsung, jika tidak, pengiraan fungsi dilakukan dan hasilnya ditambahkan pada kamus cache.

4. Ringkasan

Artikel ini memperkenalkan cara menggunakan ungkapan biasa Python untuk menghafal kod. Dengan menggunakan penghias dan ungkapan biasa, kami boleh mengurus cache hasil pelaksanaan fungsi dengan lebih baik, mengelakkan pengiraan berulang dan meningkatkan kecekapan pelaksanaan kod. Dalam aplikasi praktikal, kami juga perlu mempertimbangkan isu seperti tamat tempoh cache dan kawalan kapasiti untuk menggunakan teknologi hafalan dengan lebih baik.

Atas ialah kandungan terperinci Cara menggunakan ungkapan biasa Python untuk menghafal kod. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!