Pemprosesan Asinkron dalam Python

Artikel ini menjelaskan pemprosesan asinkron dalam Python.

Anda boleh mempelajari contoh kod untuk penggunaan asas async/await dan modul asyncio dalam Python.

YouTube Video

Pemprosesan Asinkron dalam Python

Pemprosesan tak segerak dalam Python adalah satu mekanisme untuk mengendalikan operasi I/O yang memakan masa, seperti membaca dan menulis fail atau komunikasi rangkaian, dengan cekap. Dalam pemprosesan segerak, operasi seterusnya akan menunggu sehingga operasi semasa selesai, tetapi dengan pemprosesan tak segerak, anda boleh meneruskan tugasan lain semasa masa menunggu itu. Dalam Python, modul asyncio disediakan untuk melakukan pemprosesan tak segerak. Di sini, kami akan menerangkan elemen asasnya dan cara menggunakannya langkah demi langkah.

Sintaks Asas

Pada teras pemprosesan tak segerak adalah fungsi yang dipanggil coroutine. Fungsi async mentakrifkan fungsi asinkron, dan await digunakan untuk menunggu tugas asinkron dalam fungsi tersebut.

 1import asyncio
 2
 3async def say_hello():
 4    print("Hello")
 5    await asyncio.sleep(1)
 6    print("World")
 7
 8if __name__ == "__main__":
 9    # Execute asynchronous task
10    asyncio.run(say_hello())

• Dalam kod di atas, fungsi say_hello ditakrifkan sebagai tugas asinkron. Semasa menunggu selama 1 saat dengan sleep(), tugasan asinkron yang lain mungkin akan dijalankan.

Melaksanakan Pelbagai Tugas

Dengan menggunakan fungsi gather dari modul asyncio, anda boleh menjalankan beberapa tugasan secara serentak.

 1import asyncio
 2
 3async def task1():
 4    print("Task 1 started")
 5    await asyncio.sleep(2)
 6    print("Task 1 completed")
 7
 8async def task2():
 9    print("Task 2 started")
10    await asyncio.sleep(1)
11    print("Task 2 completed")
12
13async def main():
14    await asyncio.gather(task1(), task2())
15
16if __name__ == "__main__":
17    asyncio.run(main())

• Dalam contoh ini, task1 dan task2 dilaksanakan secara serentak. Hasilnya, task2 selesai terlebih dahulu daripada kedua-dua tugas tersebut, tetapi jumlah masa pelaksanaan adalah sama dengan masa pelaksanaan tugas yang paling lama.

Pengendalian Ralat

Pengendalian ralat adalah penting walaupun dalam pemprosesan asinkron. Anda boleh menangkap dan mengendalikan ralat menggunakan sintaks standard try-except.

 1import asyncio
 2
 3async def faulty_task():
 4    raise Exception("An error occurred")
 5
 6async def main():
 7    try:
 8        await faulty_task()
 9    except Exception as e:
10        print(f"Caught an error: {e}")
11
12if __name__ == "__main__":
13    asyncio.run(main())

• Kod ini menunjukkan bagaimana pengecualian yang berlaku di dalam fungsi tak segerak boleh ditangkap dengan try-except dan mesej ralatnya boleh dikendalikan dengan selamat. Pengecualian daripada faulty_task ditangkap di dalam main dan dikeluarkan dengan sewajarnya.

Ringkasan

Pemprosesan tak segerak dalam Python menggunakan async / await dan asyncio untuk melaksanakan tugasan lain secara serentak semasa menunggu I/O, membolehkan pemprosesan yang cekap. Dengan memanfaatkan pelaksanaan serentak pelbagai tugasan dan I/O tak segerak, anda boleh meningkatkan prestasi dengan ketara. Selain itu, kerana anda boleh mengendalikan ralat seperti biasa dengan try-except, anda boleh menjalankan kod tak segerak dengan selamat.

Anda boleh mengikuti artikel di atas menggunakan Visual Studio Code di saluran YouTube kami. Sila lihat juga saluran YouTube kami.

YouTube Video