Kem Intensif Pembangunan Bahagian Belakang FastAPI · Pelajaran

FastAPI dan Operasi Tak Segerak

Fahami cara FastAPI mengendalikan fungsi tak segerak secara semula jadi serta cara menulis kod tidak menyekat yang cekap.

Pelajaran 2 daripada 411 langkah

FastAPI dan Operasi Tak Segerak ialah pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Sebanyak 3 pelajaran dalam laluan pembelajaran ini boleh dibaca sepenuhnya secara percuma — selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan praktikal dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Asas Tak Segerak FastAPI

FastAPI dibina untuk kelajuan! FastAPI memanfaatkan ciri tak segerak Python untuk mengendalikan banyak permintaan secara serentak, khususnya tugas terikat I/O.

Ini bermakna API Anda boleh terus responsif walaupun sedang menunggu sumber luaran seperti pangkalan data atau API lain.

Titik Akhir Segerak berbanding Tak Segerak

Dalam FastAPI, Anda boleh mentakrifkan dua jenis utama fungsi titik akhir:

Segerak (def): Fungsi ini menyekat gelung peristiwa semasa dijalankan. Jika satu permintaan mengambil masa yang lama, permintaan lain mungkin terpaksa menunggu.
Tak segerak (async def): Fungsi ini boleh 'dijeda' dan membenarkan tugas lain berjalan semasa menunggu sesuatu operasi, seperti membaca daripada pangkalan data, lalu menjadikan API Anda tidak menyekat.

Titik Akhir Segerak Ringkas

Berikut ialah titik akhir segerak yang standard. Walaupun ringkas, jika time.sleep() merupakan panggilan pangkalan data sebenar yang perlahan, ia akan menyekat permintaan lain sehingga selesai.

Cuba jalankannya dan perhatikan kelewatan jika Anda cuba membuat beberapa permintaan dengan pantas.

from fastapi import FastAPI
import uvicorn
import time

app = FastAPI()

@app.get("/sync_hello")
def sync_hello():
    time.sleep(2) # Simulate a blocking I/O operation
    return {"message": "Hello from sync endpoint!"}

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

Mentakrifkan Titik Akhir Tak Segerak

Untuk menjadikan titik akhir Anda tidak menyekat, gunakan async def. Ini memberitahu FastAPI dan Python bahawa fungsi ini boleh digantung sementara dan disambung semula.

Di dalam fungsi async def, Anda menggunakan kata kunci await untuk menunggu operasi tak segerak lain selesai tanpa menyekat keseluruhan aplikasi.

Titik Akhir Tak Segerak Pertama Anda

Contoh ini menggunakan asyncio.sleep(), iaitu fungsi tidur tak segerak. Perhatikan kata kunci await yang mendahuluinya.

Ini membolehkan FastAPI mengendalikan permintaan lain semasa permintaan ini 'tidur', lalu menjadikan pelayan lebih responsif.

from fastapi import FastAPI
import uvicorn
import asyncio

app = FastAPI()

@app.get("/async_hello")
async def async_hello():
    await asyncio.sleep(2) # Simulate non-blocking I/O
    return {"message": "Hello from async endpoint!"}

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

Bila Perlu Menggunakan Tak Segerak

async def amat sesuai untuk operasi terikat I/O. Ini ialah tugas yang menghabiskan sebahagian besar masanya untuk menunggu sesuatu yang lain berlaku, seperti:

Membuat permintaan kepada API luaran, contohnya httpx.
Menyoal pangkalan data, contohnya asyncpg dan SQLModel.
Membaca dan menulis fail daripada cakera.
Komunikasi rangkaian.

Untuk tugas terikat CPU, iaitu pengiraan berat, async def tidak mempercepatkan tugas itu sendiri, tetapi boleh membantu memastikan pelayan kekal responsif.

Berinteraksi dengan Pustaka Tak Segerak

Apabila titik akhir FastAPI async def Anda perlu berinteraksi dengan pustaka tak segerak lain, seperti klien HTTP tak segerak atau pemacu pangkalan data tak segerak, Anda mesti menggunakan await.

Jika tidak menggunakan await, objek awaitable akan dikembalikan secara langsung, bukannya hasil yang telah diselesaikan, dan biasanya bukan itu yang Anda inginkan!

Panggilan API Tak Segerak Secara Konseptual

Bayangkan Anda mendapatkan data daripada perkhidmatan lain. Klien HTTP tak segerak membolehkan perkara ini dilakukan tanpa sekatan. Beginilah gambaran konsepnya dalam titik akhir async def:

Kita mensimulasikan kependaman rangkaian dengan asyncio.sleep untuk menunjukkan sifat tanpa sekatan.

from fastapi import FastAPI
import uvicorn
import asyncio

app = FastAPI()

@app.get("/fetch_data")
async def fetch_external_data():
    # In a real app, you'd use an async HTTP client like 'httpx'
    # async with httpx.AsyncClient() as client:
    #     response = await client.get("https://api.example.com/data")
    #     data = response.json()

    await asyncio.sleep(1) # Simulate network latency
    return {"data": "Fetched async data!"}

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

Uvicorn: Enjin Tak Segerak

FastAPI bergantung pada pelayan ASGI seperti Uvicorn. Uvicornlah yang sebenarnya menjalankan fungsi async def Anda dengan cekap.

Uvicorn mengurus gelung peristiwa Python, yang menyusun atur masa tugas tak segerak yang berbeza boleh dijalankan.
Apabila await ditemui, Uvicorn boleh bertukar kepada tugas lain yang sudah sedia, lalu menjadikan API Anda sangat serentak.

'Pertukaran konteks' inilah yang membolehkan FastAPI mengendalikan banyak permintaan tanpa menunggu setiap permintaan selesai sepenuhnya.

Semakan Pantas: Penggunaan Tak Segerak

Anda sedang membina titik akhir FastAPI yang perlu mendapatkan data daripada API luaran yang perlahan, iaitu tugas terikat I/O. Antara pilihan berikut, yang manakah cara terbaik untuk mentakrifkan titik akhir ini supaya aplikasi FastAPI Anda kekal responsif?

Jawab dalam pelajaran interaktif

Ulang Kaji: FastAPI Tak Segerak

Kita telah meneroka cara FastAPI memanfaatkan ciri tak segerak Python:

Gunakan async def untuk fungsi titik akhir yang melaksanakan operasi terikat I/O.
Gunakan await apabila memanggil fungsi atau pustaka tak segerak lain di dalam async def.
Pendekatan tanpa sekatan ini, yang dikuasakan oleh Uvicorn dan gelung peristiwa, membolehkan aplikasi FastAPI Anda mengendalikan banyak permintaan serentak dengan cekap, lalu menghasilkan API yang sangat responsif.

Seterusnya, kita akan melihat cara memindahkan tugas yang benar-benar mengambil masa lama atau terikat CPU kepada proses latar belakang!

Percuma untuk bermula

Pelajari Kem Intensif Pembangunan Bahagian Belakang FastAPI dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 21
Pelajaran: 84

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “FastAPI dan Operasi Tak Segerak” percuma?

Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, termasuk “FastAPI dan Operasi Tak Segerak”, boleh dibaca sepenuhnya secara percuma di web ini. Selepas itu, CoddyKit PRO membuka akses kepada semua pelajaran, serta latihan interaktif dengan penyunting kod terbina dalam dan tutor kecerdasan buatan yang tersedia 24/7. Kursus Kem Intensif Pembangunan Bahagian Belakang FastAPI merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “FastAPI dan Operasi Tak Segerak”?

Fahami cara FastAPI mengendalikan fungsi tak segerak secara semula jadi serta cara menulis kod tidak menyekat yang cekap. Anda berlatih Kem Intensif Pembangunan Bahagian Belakang FastAPI menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Kem Intensif Pembangunan Bahagian Belakang FastAPI?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “FastAPI dan Operasi Tak Segerak” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI ini?

Ya. Setiap pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Kem Intensif Pembangunan Bahagian Belakang FastAPI