Cara menggunakan ungkapan biasa Python untuk operasi serentak

Dalam pengaturcaraan Python, ungkapan biasa ialah alat yang sangat berkuasa dan biasa digunakan yang boleh digunakan untuk memadankan dan memproses rentetan. Ungkapan biasa juga boleh memainkan peranan penting dalam pengaturcaraan serentak, terutamanya apabila sejumlah besar rentetan perlu diproses secara serentak.

Artikel ini akan memperkenalkan cara menggunakan ungkapan biasa Python untuk operasi serentak, termasuk cara menggunakan multi-threading, coroutine, IO tak segerak dan teknologi lain untuk mencapai pemprosesan rentetan serentak.

1. Gunakan multi-threading untuk operasi serentak

Menggunakan multi-threading ialah salah satu kaedah yang paling biasa untuk melaksanakan pemprosesan serentak. Dalam Python, anda boleh menggunakan modul threading untuk mencipta dan mengurus thread. Berikut ialah contoh mudah yang menunjukkan cara menggunakan multithreading untuk memproses berbilang rentetan:

import threading
import re

def match_string(pattern, string):
    match = re.search(pattern, string)
    if match:
        print(match.group())

patterns = [r'food', r'bard', r'bazd']
strings = ['foo1 bar2 baz3', 'bar4 baz5 foo6', 'baz7 foo8 bar9']

threads = []
for pattern in patterns:
    for string in strings:
        thread = threading.Thread(target=match_string, args=(pattern, string))
        thread.start()
        threads.append(thread)

for thread in threads:
    thread.join()

Dalam contoh ini, kami menggunakan tiga corak ungkapan biasa (makanan, bard dan bazd) dan tiga A senarai rentetan ('foo1 bar2 baz3', 'bar4 baz5 foo6' dan 'baz7 foo8 bar9'), sembilan utas dicipta untuk melaksanakan fungsi match_string. Fungsi match_string menerima dua parameter: corak ungkapan biasa dan rentetan Ia mencari rentetan untuk subrentetan yang sepadan dengan corak dan mencetak subrentetan.

Dengan menggunakan berbilang benang, kami boleh memproses berbilang rentetan dan corak pada masa yang sama, meningkatkan kecekapan pemprosesan rentetan.

2. Gunakan coroutine untuk operasi serentak

Coroutine ialah teknologi pengaturcaraan serentak ringan yang membolehkan kami melaksanakan operasi serentak dalam satu urutan. Dalam Python, anda boleh menggunakan modul asyncio untuk mencipta dan mengurus coroutine. Berikut ialah contoh mudah yang menunjukkan cara menggunakan coroutine untuk memproses berbilang rentetan:

import asyncio
import re

async def match_string(pattern, string):
    match = re.search(pattern, string)
    if match:
        print(match.group())

patterns = [r'food', r'bard', r'bazd']
strings = ['foo1 bar2 baz3', 'bar4 baz5 foo6', 'baz7 foo8 bar9']

async def main():
    tasks = []
    for pattern in patterns:
        for string in strings:
            task = asyncio.create_task(match_string(pattern, string))
            tasks.append(task)

    await asyncio.gather(*tasks)

asyncio.run(main())

Dalam contoh ini, kami menggunakan modul asyncio untuk mencipta dan mengurus coroutine. Kami mula-mula mentakrifkan fungsi async match_string, yang sama dengan fungsi match_string dalam contoh sebelumnya Perbezaannya ialah ia menggunakan kata kunci async, menunjukkan bahawa fungsi itu ialah coroutine. Kami juga mentakrifkan fungsi utama async, yang mencipta berbilang coroutine untuk mengendalikan berbilang rentetan dan corak.

Dalam fungsi utama, kami menggunakan fungsi asyncio.create_task untuk mencipta setiap coroutine dan menambahkannya pada senarai tugas. Kemudian, kami menggunakan fungsi asyncio.gather untuk melaksanakan semua tugasan secara serentak dan menunggu semua tugasan selesai.

Dengan menggunakan coroutine, kami boleh memproses berbilang rentetan secara serentak dalam satu benang, mengelakkan penukaran benang overhed dan isu keselamatan benang dalam pengaturcaraan berbilang benang.

3. Gunakan IO tak segerak untuk operasi serentak

IO Asynchronous ialah teknologi pengaturcaraan serentak yang cekap yang boleh menggunakan sepenuhnya sumber CPU dan IO komputer dan meningkatkan keupayaan pemprosesan serentak program. Dalam Python, anda boleh menggunakan modul asyncio untuk melaksanakan IO asynchronous. Berikut ialah contoh mudah yang menunjukkan cara menggunakan IO tak segerak untuk memproses berbilang rentetan:

import asyncio
import aiohttp
import re

async def match_string(pattern, string):
    async with aiohttp.ClientSession() as session:
        async with session.get(string) as response:
            text = await response.text()
            match = re.search(pattern, text)
            if match:
                print(match.group())

patterns = [r'Python', r'Java', r'C#']
urls = ['https://www.python.org', 'https://www.java.com', 'https://docs.microsoft.com/en-us/dotnet/csharp/']

async def main():
    tasks = []
    for pattern in patterns:
        for url in urls:
            task = asyncio.create_task(match_string(pattern, url))
            tasks.append(task)

    await asyncio.gather(*tasks)

asyncio.run(main())

Dalam contoh ini, kami menggunakan modul aiohttp untuk melaksanakan operasi IO tak segerak. Kami mula-mula mentakrifkan fungsi async match_string, yang menerima corak ungkapan biasa dan rentetan URL Ia akan mencari subrentetan yang sepadan dengan corak dalam halaman URL yang ditentukan dan mencetak subrentetan itu. Untuk melaksanakan operasi IO tak segerak, kami menggunakan kata kunci tak segerak dan tak segerak dengan pernyataan untuk merangkum kelas ClientSession dalam modul aiohttp ke dalam pengurus konteks tak segerak dan memproses permintaan dan respons HTTP di dalamnya.

Dalam fungsi utama, kami mencipta berbilang coroutine untuk melaksanakan fungsi match_string dan menggunakan fungsi asyncio.gather untuk melaksanakan semua coroutine secara serentak dan menunggu sehingga ia selesai. Dengan cara ini, kami boleh memproses permintaan dan respons HTTP untuk berbilang halaman URL pada masa yang sama, meningkatkan keupayaan pemprosesan serentak program ini.

Kesimpulan

Dalam artikel ini, kami memperkenalkan cara menggunakan ungkapan biasa Python untuk operasi serentak, termasuk menggunakan teknologi seperti multi-threading, coroutine dan IO tak segerak untuk mencapai pemprosesan rentetan serentak. Setiap teknologi ini mempunyai kelebihan dan kekurangan, dan kaedah yang sesuai harus dipilih berdasarkan senario aplikasi tertentu. Dengan menggunakan teknologi ini secara rasional, kami boleh menggunakan sepenuhnya sumber berbilang teras dan IO komputer dan meningkatkan kecekapan berjalan dan keupayaan serentak program.

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