Penyahpepijatan Aplikasi FastAPI
Kuasai teknik penyahpepijatan untuk FastAPI, termasuk penggunaan penyahpepijat IDE dan pengelogan.
Penyahpepijatan Aplikasi FastAPI ialah pelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI percuma di CoddyKit. Ini ialah pelajaran 3 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 Penyahpepijatan?
Selamat datang ke penyahpepijatan! Sebagai pembangun, kita bukan sekadar menulis kod; kita juga membaikinya. Penyahpepijatan ialah proses mencari dan menyelesaikan ralat atau “pepijat” dalam perisian anda.
Ini ialah kemahiran penting yang membantu anda memahami tingkah laku sebenar kod anda, bukan sekadar tingkah laku yang anda jangkakan.
- Cari Ralat: Kenal pasti lokasi sebenar berlakunya masalah.
- Fahami Aliran: Jejaki laluan pelaksanaan.
- Periksa Keadaan: Lihat nilai pemboleh ubah pada bila-bila masa.
Penyahpepijatan `print()` Ringkas
Bentuk penyahpepijatan yang paling asas ialah menggunakan pernyataan print(). Anda boleh menyelitkannya di seluruh kod untuk melihat nilai pemboleh ubah atau mengesahkan sama ada bahagian tertentu kod sedang dilaksanakan.
Walaupun pantas, pernyataan print() boleh mengganggu output anda dan perlu dibuang secara manual kemudian.
Cuba jalankan contoh ringkas ini:
def calculate_sum(a, b):
print(f"DEBUG: Input: a={a}, b={b}")
result = a + b
print(f"DEBUG: Output: result={result}")
return result
if __name__ == "__main__":
print("Starting calculation...")
total = calculate_sum(5, 3)
print(f"Final total: {total}")Pengelogan Berstruktur dengan Python
Untuk penyahpepijatan dan pemantauan aplikasi yang lebih mantap, modul logging terbina dalam Python jauh lebih baik berbanding print(). Modul ini membolehkan anda mengkategorikan mesej mengikut tahap keseriusan.
Tahap log utama:
- DEBUG: Maklumat terperinci, biasanya hanya untuk pembangunan.
- INFO: Pengesahan bahawa semuanya berfungsi seperti yang dijangkakan.
- WARNING: Sesuatu yang tidak dijangka berlaku, tetapi perisian masih berfungsi.
- ERROR: Masalah serius yang menyebabkan perisian tidak dapat melaksanakan sesuatu fungsi.
- CRITICAL: Ralat yang sangat serius dan program mungkin tidak dapat diteruskan.
Pengelogan Asas dalam Tindakan
Dengan logging, anda boleh mengawal mesej yang dipaparkan berdasarkan tahapnya. Anda juga boleh menghalakan log ke fail, rangkaian atau destinasi lain, menjadikannya jauh lebih fleksibel berbanding print().
Jalankan contoh ini untuk melihat pelbagai tahap log dalam tindakan:
import logging
# Configure basic logging to show DEBUG level and above
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
def process_data(data):
logging.debug(f"Attempting to process data: {data}")
if not data:
logging.warning("Received empty data for processing!")
return []
processed = [item.upper() for item in data]
logging.info(f"Data processed successfully. Items count: {len(processed)}")
return processed
if __name__ == "__main__":
logging.info("Application started.")
result1 = process_data(["apple", "banana"])
print(f"Result 1: {result1}")
result2 = process_data([])
print(f"Result 2: {result2}")
logging.info("Application finished.")Mengintegrasikan Pengelogan dengan FastAPI
Aplikasi FastAPI yang dikuasakan oleh Uvicorn sudah menggunakan modul logging Python. Apabila anda menambahkan pengelogan sendiri, anda biasanya dapat melihatnya bersama-sama output Uvicorn.
Anda boleh mencipta pengelog bernama untuk aplikasi anda supaya mesej dapat disusun dengan lebih baik dan outputnya dikawal secara berasingan.
Berikut ialah contoh FastAPI ringkas dengan pengelogan bersepadu:
import logging
from fastapi import FastAPI
import uvicorn
# Get a logger for our application module
logger = logging.getLogger("my-fastapi-app")
logger.setLevel(logging.INFO) # Set default level for this logger
# Add a console handler to the logger (if not already configured by uvicorn)
# This is often handled by uvicorn itself, but good to know for custom setup
handler = logging.StreamHandler()
handler.setFormatter(logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s'))
logger.addHandler(handler)
app = FastAPI()
@app.get("/hello/{name}")
async def say_hello(name: str):
logger.info(f"API call: /hello/{name}")
if name == "error":
logger.error("Simulating an intentional error condition!")
return {"message": f"Hello {name}, but an error occurred.", "status": "failed"}
logger.debug(f"Successfully processed name: {name}") # Won't show with INFO level
return {"message": f"Hello {name}", "status": "success"}
if __name__ == "__main__":
# In a real setup, you'd run `uvicorn main:app --reload`
# This block allows direct execution for demonstration
logger.info("Starting FastAPI application for demonstration...")
uvicorn.run(app, host="0.0.0.0", port=8000, log_level="info")Fungsi `breakpoint()` Python
Sejak Python 3.7, anda boleh menggunakan fungsi breakpoint() terbina dalam untuk menjeda pelaksanaan program pada baris tertentu.
Apabila breakpoint() dipanggil, Python akan membawa anda ke penyahpepijat, biasanya pdb, iaitu Penyahpepijat Python. Dari situ, anda boleh memeriksa pemboleh ubah, melangkah melalui kod dan melakukan lebih banyak lagi.
Ini sangat berkuasa untuk penyahpepijatan interaktif tanpa memerlukan persediaan IDE yang lengkap.
def calculate_discount(price, discount_percentage):
if not (0 <= discount_percentage <= 100):
print("Invalid discount percentage.")
return price
discount_amount = price * (discount_percentage / 100)
# Uncomment the line below to pause execution here!
# breakpoint()
final_price = price - discount_amount
return final_price
if __name__ == "__main__":
print("Calculating final price...")
item_price = 100
discount = 15
final = calculate_discount(item_price, discount)
print(f"Original price: ${item_price}, Discount: {discount}%, Final price: ${final}")Kuasa Penyahpepijat IDE
Penyahpepijat Persekitaran Pembangunan Bersepadu (IDE), seperti yang terdapat dalam VS Code, PyCharm atau perisian lain, ialah alat penyahpepijatan yang paling berkuasa. Alat ini menyediakan antara muka visual untuk mengawal pelaksanaan program anda.
Manfaat utama:
- Titik Henti Visual: Klik untuk menetapkan atau memadamkannya.
- Pelaksanaan Langkah demi Langkah: Kawal aliran dengan tepat.
- Pemeriksaan Pemboleh Ubah: Lihat semua nilai pemboleh ubah dalam masa nyata.
- Timba Panggilan: Fahami cara anda sampai ke titik semasa.
Menetapkan dan Menggunakan Titik Henti
Titik henti ialah penanda yang anda letakkan dalam kod untuk memberitahu penyahpepijat supaya menjeda pelaksanaan apabila baris tersebut dicapai. Ini membolehkan anda 'membekukan' program pada detik tertentu.
Dalam kebanyakan IDE, anda menetapkan titik henti dengan hanya mengklik pada ruang di sebelah kiri nombor baris, bersebelahan baris kod yang ingin dijeda. Apabila anda menjalankan aplikasi dalam mod penyahpepijatan, aplikasi akan berhenti di situ.
Menavigasi Kod: Langkau, Masuk, Keluar
Selepas pelaksanaan dijeda pada titik henti, penyahpepijat IDE menyediakan kawalan untuk menavigasi kod anda:
- Langkau: Melaksanakan baris kod semasa dan beralih ke baris seterusnya. Jika baris semasa memanggil fungsi, penyahpepijat melaksanakan keseluruhan fungsi tanpa memasukinya.
- Masuk: Jika baris semasa mengandungi panggilan fungsi, penyahpepijat akan masuk ke dalam fungsi tersebut supaya anda boleh menyahpepijat logik dalamannya.
- Keluar: Melaksanakan baki fungsi semasa dan kembali ke baris tempat fungsi itu dipanggil.
Semakan Pengetahuan Penyahpepijatan
Mari uji pemahaman anda tentang teknik penyahpepijatan.
Ulang Kaji Asas Penyahpepijatan
Tahniah! Anda telah meneroka teknik penyahpepijatan utama untuk aplikasi FastAPI dan kod Python anda.
print(): Cara pantas dan kasar untuk pemeriksaan segera.- Modul
logging: Berstruktur, fleksibel dan boleh diskalakan untuk pengeluaran serta pembangunan. breakpoint(): Cara terbina dalam Python untuk menjeda pelaksanaan dan memasuki penyahpepijat.- Penyahpepijat IDE: Alat paling berkuasa untuk pelaksanaan visual langkah demi langkah dan pemeriksaan keadaan.
Menguasai semua ini akan mempercepat proses pembangunan dan penyelesaian masalah anda dengan ketara. Teruskan berlatih!
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 “Penyahpepijatan Aplikasi FastAPI” percuma?
Ya — sebanyak 3 pelajaran dalam laluan pembelajaran Kem Intensif Pembangunan Bahagian Belakang FastAPI, termasuk “Penyahpepijatan Aplikasi 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 “Penyahpepijatan Aplikasi FastAPI”?
Kuasai teknik penyahpepijatan untuk FastAPI, termasuk penggunaan penyahpepijat IDE dan pengelogan. 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 3 daripada 4.
Berapa lamakah pelajaran “Penyahpepijatan Aplikasi 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
- Ujian Unit dengan Pytest
- Ujian Integrasi Titik Akhir FastAPI
- Penyahpepijatan Aplikasi FastAPI
- Penyamaran Kebergantungan dalam Pengujian FastAPI