Pengaturcaraan Segerak dan Asynchronous dalam Python: Konsep dan Aplikasi Utama

Pengaturcaraan Segerak
Dalam pengaturcaraan segerak, tugasan dilaksanakan satu demi satu. Setiap tugasan mesti diselesaikan sebelum tugasan seterusnya bermula. Pendekatan linear ini mudah tetapi boleh menjadi tidak cekap, terutamanya apabila berurusan dengan operasi terikat I/O seperti pembacaan fail, permintaan rangkaian atau pertanyaan pangkalan data.

import time

def task1():
    print("Starting task 1...")
    time.sleep(2)
    print("Task 1 completed")

def task2():
    print("Starting task 2...")
    time.sleep(2)
    print("Task 2 completed")

def main():
    task1()
    task2()

if __name__ == "__main__":
    main()

Dalam contoh ini, tugas1 mesti diselesaikan sebelum tugas2 bermula. Jumlah masa pelaksanaan ialah jumlah masa yang diambil oleh setiap tugasan.

Pengaturcaraan Tak Segerak
Pengaturcaraan tak segerak membolehkan berbilang tugasan dijalankan serentak, meningkatkan kecekapan, terutamanya untuk tugas terikat I/O. Pustaka asyncio Python menyediakan alatan yang diperlukan untuk pengaturcaraan tak segerak.

import asyncio

async def task1():
    print("Starting task 1...")
    await asyncio.sleep(2)
    print("Task 1 completed")

async def task2():
    print("Starting task 2...")
    await asyncio.sleep(2)
    print("Task 2 completed")

async def main():
    await asyncio.gather(task1(), task2())

if __name__ == "__main__":
    asyncio.run(main())

Dalam contoh ini, tugas1 dan tugas2 dijalankan serentak, mengurangkan jumlah masa pelaksanaan kepada masa yang diambil oleh tugasan terpanjang.

Aplikasi Berpotensi

Pelayan Web dan API:

• Segerak: Rangka kerja web tradisional seperti Flask mengendalikan permintaan secara berurutan. Ini boleh menjadi halangan apabila mengendalikan sejumlah besar permintaan.
• Asynchronous: Rangka kerja seperti FastAPI dan aiohttp menggunakan pengaturcaraan tak segerak untuk mengendalikan berbilang permintaan serentak, meningkatkan daya pengeluaran dan prestasi.

Aplikasi Pemesejan Masa Nyata:

• Segerak: Mengendalikan mesej masa nyata boleh menyebabkan kelewatan jika setiap mesej diproses secara berurutan.
• Asynchronous: Menggunakan WebSockets dengan pengendalian tak segerak (cth., pustaka websockets) membolehkan komunikasi dwiarah masa nyata, mendayakan aplikasi sembang berprestasi tinggi, pemberitahuan langsung, dsb.

Saluran Paip Pemprosesan Data:

• Segerak: Memproses set data yang besar secara berurutan boleh memakan masa.
• Asynchronous: Tugas asynchronous boleh mengambil, memproses dan menyimpan data secara serentak, dengan ketara mengurangkan masa pemprosesan. Perpustakaan seperti aiohttp dan aiomysql boleh digunakan untuk permintaan HTTP tak segerak dan operasi pangkalan data.

Mengikis Web:

• Segerak: Mengambil halaman web secara berurutan boleh menjadi perlahan dan tidak cekap.
• Asynchronous: Menggunakan aiohttp untuk permintaan HTTP tak segerak boleh mengambil berbilang halaman web secara serentak, mempercepatkan proses mengikis web.

Operasi I/O Fail:

• Segerak: Membaca/menulis fail besar secara berurutan boleh menyekat operasi lain.
• Asynchronous: Operasi I/O fail tak segerak menggunakan aiofiles boleh meningkatkan prestasi dengan membenarkan tugasan lain dijalankan serentak.

Memilih Antara Segerak dan Tak Segerak

• Gunakan pengaturcaraan segerak untuk tugas terikat CPU di mana operasinya adalah intensif dari segi pengiraan dan mendapat manfaat daripada berjalan secara berurutan.
• Gunakan pengaturcaraan tak segerak untuk tugas terikat I/O di mana operasi melibatkan menunggu sumber luaran, seperti permintaan rangkaian, fail I/O atau pertanyaan pangkalan data.

Contoh Aplikasi Pemesejan Masa Nyata
Mari buat aplikasi pemesejan masa nyata asas menggunakan FastAPI untuk bahagian belakang dan WebSockets untuk komunikasi masa nyata. Kami akan menggunakan Streamlit untuk bahagian hadapan untuk memaparkan mesej.

Backend (FastAPI + WebSockets)

1.Pasang Ketergantungan:
pip pasang fastapi uvicorn websockets

2.Kod Belakang (backend.py):

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.responses import HTMLResponse
from typing import List

app = FastAPI()

class ConnectionManager:
    def __init__(self):
        self.active_connections: List[WebSocket] = []

    async def connect(self, websocket: WebSocket):
        await websocket.accept()
        self.active_connections.append(websocket)

    def disconnect(self, websocket: WebSocket):
        self.active_connections.remove(websocket)

    async def send_message(self, message: str):
        for connection in self.active_connections:
            await connection.send_text(message)

manager = ConnectionManager()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await manager.connect(websocket)
    try:
        while True:
            data = await websocket.receive_text()
            await manager.send_message(data)
    except WebSocketDisconnect:
        manager.disconnect(websocket)

@app.get("/")
async def get():
    return HTMLResponse("""
    <!DOCTYPE html>
    <html>
    <head>
        <title>Chat</title>
    </head>
    <body>
        <h1>WebSocket Chat</h1>
        <form action="" onsubmit="sendMessage(event)">
            <input type="text" id="messageText" autocomplete="off"/>
            <button>Send</button>
        </form>
        <ul id='messages'>
        </ul>
        <script>
            var ws = new WebSocket("ws://localhost:8000/ws");
            ws.onmessage = function(event) {
                var messages = document.getElementById('messages');
                var message = document.createElement('li');
                message.appendChild(document.createTextNode(event.data));
                messages.appendChild(message);
            };

            function sendMessage(event) {
                var input = document.getElementById("messageText");
                ws.send(input.value);
                input.value = '';
                event.preventDefault();
            }
        </script>
    </body>
    </html>
    """)

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

Hadapan (Strim)

1. Pasang Ketergantungan:

pip install streamlit websocket-client

1. Kod Frontend (frontend.py):

import streamlit as st
import asyncio
import threading
from websocket import create_connection, WebSocket

st.title("Real-time Messaging Application")

if 'messages' not in st.session_state:
    st.session_state.messages = []

def websocket_thread():
    ws = create_connection("ws://localhost:8000/ws")
    st.session_state.ws = ws
    while True:
        message = ws.recv()
        st.session_state.messages.append(message)
        st.experimental_rerun()

if 'ws' not in st.session_state:
    threading.Thread(target=websocket_thread, daemon=True).start()

input_message = st.text_input("Enter your message:")

if st.button("Send"):
    if input_message:
        st.session_state.ws.send(input_message)
        st.session_state.messages.append(f"You: {input_message}")

st.subheader("Chat Messages:")
for message in st.session_state.messages:
    st.write(message)

Menjalankan Aplikasi

1. Mulakan bahagian belakang FastAPI:

uvicorn backend:app

1. Mulakan bahagian hadapan Streamlit:

streamlit run frontend.py

Penjelasan
Bahagian belakang (backend.py):

• Apl FastAPI mempunyai titik akhir WebSocket di /ws.
• ConnectionManager mengendalikan sambungan WebSocket, menyiarkan mesej kepada semua pelanggan yang disambungkan.
• Titik akhir akar (/) menyediakan halaman HTML ringkas untuk menguji sambungan WebSocket.

Frontend (frontend.py):

• Apl strim bersambung ke pelayan WebSocket dan mendengar mesej masuk.
• Benang berasingan mengendalikan sambungan WebSocket untuk menghalang apl Streamlit.
• Pengguna boleh menghantar mesej menggunakan kotak input, yang kemudiannya dihantar ke pelayan WebSocket dan dipaparkan dalam sembang.

Contoh ini menunjukkan aplikasi pemesejan masa nyata yang ringkas menggunakan FastAPI dan WebSockets untuk bahagian belakang dan Streamlit untuk bahagian hadapan.

Atas ialah kandungan terperinci Pengaturcaraan Segerak dan Asynchronous dalam Python: Konsep dan Aplikasi Utama. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!