Memahami Kebergantungan dalam FastAPI
Terokai konsep suntikan kebergantungan dan cara konsep ini memudahkan penyusunan serta penggunaan semula kod dalam FastAPI.
Memahami Kebergantungan dalam FastAPI ialah pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI percuma di CoddyKit. Ini ialah pelajaran 1 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.
Apakah Suntikan Kebergantungan?
Pernahkah anda berharap fungsi anda boleh mendapatkan alat yang diperlukan secara automatik? Itulah yang dibantu oleh Suntikan Kebergantungan (DI)!
Dalam FastAPI, DI ialah corak reka bentuk yang berkuasa apabila komponen (seperti titik akhir API anda) tidak mencipta kebergantungannya sendiri. Sebaliknya, komponen tersebut mengisytiharkan perkara yang diperlukan, lalu FastAPI "menyuntikkannya".
Faedah DI FastAPI
FastAPI menggunakan DI secara meluas kerana ia menjadikan kod anda:
- Boleh digunakan semula: Tulis logik sekali dan gunakannya di mana-mana.
- Boleh diuji: Tukar perkhidmatan sebenar dengan versi olok-olok dengan mudah untuk ujian.
- Kemas: Mengekalkan fungsi operasi laluan agar fokus pada tugas utamanya.
- Mudah diselenggara: Perubahan pada kebergantungan tidak merebak ke seluruh aplikasi anda.
Membina Kebergantungan Asas
Kebergantungan dalam FastAPI biasanya hanyalah fungsi Python biasa.
Fungsi ini boleh melaksanakan sebarang persediaan, pengesahan atau pemerolehan sumber yang diperlukan sebelum logik API utama anda berjalan. Fungsi ini juga boleh mengembalikan nilai.
FastAPI akan memanggil fungsi ini secara automatik dan menghantar hasilnya kepada titik akhir anda.
Menyuntik ke dalam Titik Akhir
Untuk menggunakan kebergantungan, anda mengisytiharkannya sebagai parameter dalam fungsi operasi laluan anda menggunakan fungsi khas Depends FastAPI.
Apabila permintaan masuk, FastAPI menyemak parameter titik akhir anda, menyelesaikan sebarang kebergantungan dan kemudian memanggil titik akhir anda dengan hasil tersebut.
Kebergantungan Mudah dalam Tindakan
Mari lihat kebergantungan asas yang mengembalikan rentetan mudah. Perhatikan bahawa get_message dipanggil oleh FastAPI sebelum read_root.
from fastapi import FastAPI, Depends
app = FastAPI()
def get_message():
return "Hello from dependency!"
@app.get("/")
async def read_root(message: str = Depends(get_message)):
return {"message": message}
# To run this:
# 1. Save as main.py
# 2. pip install fastapi uvicorn
# 3. uvicorn main:app --reload
# Then visit http://127.0.0.1:8000/Kebergantungan Boleh Mempunyai Parameter
Kebergantungan tidak terhad kepada fungsi mudah. Kebergantungan juga boleh menerima parameternya sendiri, yang turut akan diselesaikan oleh FastAPI.
Ini bermakna kebergantungan itu sendiri boleh bergantung pada kebergantungan lain, lalu membentuk satu rantaian! Ini amat berkuasa untuk membina logik yang kompleks.
Kebergantungan yang Menerima Input
Di sini, greet_user ialah kebergantungan yang menerima name. Jika name tidak diberikan dalam pertanyaan, nilai lalainya ialah 'Guest'.
from fastapi import FastAPI, Depends
app = FastAPI()
def greet_user(name: str = "Guest"):
return f"Hello, {name}!"
@app.get("/greet/")
async def say_hello(greeting: str = Depends(greet_user)):
return {"greeting": greeting}
# To run this:
# uvicorn main:app --reload
# Visit http://127.0.0.1:8000/greet/
# And http://127.0.0.1:8000/greet/?name=CoddyMemahami `Depends()`
Bahagian ajaib yang menghubungkan titik akhir anda dengan kebergantungan ialah fungsi Depends().
- Ia memberitahu FastAPI: "Hei, sebelum menjalankan fungsi ini, sila selesaikan kebergantungan ini."
- Anda menghantar fungsi kebergantungan (atau objek boleh panggil) terus kepada
Depends(), bukan hasil fungsi tersebut. - FastAPI mengendalikan pemanggilan fungsi kebergantungan anda bagi pihak anda.
Kes Penggunaan Kebergantungan
Kebergantungan amat sesuai untuk:
- Sambungan pangkalan data: Dapatkan satu sesi bagi setiap permintaan.
- Pengesahan identiti: Sahkan kelayakan pengguna.
- Kebenaran: Semak peranan atau keizinan pengguna.
- Logik dikongsi: Sebarang kod yang diperlukan oleh beberapa titik akhir.
Kebergantungan memastikan API anda kemas dan fokus.
Semakan Konsep Kebergantungan
Pertimbangkan petikan kod FastAPI berikut:
from fastapi import FastAPI, Depends
app = FastAPI()
def get_db_session():
# Imagine this connects to a database
return "Database Session Object"
@app.get("/items/")
async def read_items(session: str = Depends(get_db_session)):
return {"message": f"Using {session}"}Apakah nilai session di dalam fungsi read_items apabila permintaan dibuat kepada /items/?
Imbas Kembali: Kebergantungan Dijelaskan
Anda telah mengambil langkah penting untuk menguasai FastAPI dengan memahami Suntikan Kebergantungan!
- Kebergantungan ialah fungsi yang dijalankan oleh FastAPI sebelum titik akhir anda.
- Kebergantungan menjadikan kod anda modular, boleh digunakan semula dan boleh diuji.
- Anda mengisytiharkannya menggunakan
param: Type = Depends(your_dependency_func).
Seterusnya, kita akan meneroka corak kebergantungan yang lebih biasa dan lanjutan!
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
Soalan Lazim
Adakah pelajaran “Memahami Kebergantungan dalam FastAPI” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, termasuk “Memahami Kebergantungan dalam FastAPI”, 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 “Memahami Kebergantungan dalam FastAPI”?
Terokai konsep suntikan kebergantungan dan cara konsep ini memudahkan penyusunan serta penggunaan semula kod dalam FastAPI. 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 1 daripada 4.
Berapa lamakah pelajaran “Memahami Kebergantungan dalam FastAPI” 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
- Memahami Kebergantungan dalam FastAPI
- Menyuntik Kebergantungan Umum
- Kebergantungan Berasaskan Kelas dan Yield
- Kebergantungan Global dan Subkebergantungan