FastAPI Backend Development Bootcamp · درس

تصحيح أخطاء تطبيقات FastAPI

أتقنوا تقنيات تصحيح أخطاء FastAPI، بما في ذلك استخدام أدوات التصحيح في بيئات التطوير المتكاملة وتسجيل الأحداث.

تصحيح أخطاء تطبيقات FastAPI درس مجاني في FastAPI Backend Development Bootcamp على CoddyKit. هذا هو الدرس 3 من أصل 4. يمكنك قراءة الدرس كاملاً أدناه مجاناً — ثم تمرن عليه مباشرة في المتصفح باستخدام محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7. هذا الدرس جزء من مسار التعلم في FastAPI Backend Development Bootcamp، وتقدمك يتزامن عبر الويب وتطبيق CoddyKit. تتضمن دورة FastAPI Backend Development Bootcamp 4 دروس في المجموع.

بعض أجزاء هذا الدرس لم تُترجم بعد وتظهر باللغة الإنجليزية.

What is Debugging?

Welcome to debugging! As developers, we don't just write code; we also fix it. Debugging is the process of finding and resolving errors or 'bugs' in your software.

It's an essential skill that helps you understand how your code truly behaves, not just how you think it should.

Find Errors: Pinpoint exactly where issues occur.
Understand Flow: Trace execution path.
Inspect State: See variable values at any point.

The Simple `print()` Debug

The most basic form of debugging is using print() statements. You can sprinkle them throughout your code to see values of variables or confirm if a certain part of your code is being executed.

While quick, print() statements can clutter your output and need to be manually removed later.

Try running this simple example:

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}")

Structured Logging with Python

For more robust debugging and application monitoring, Python's built-in logging module is far superior to print(). It allows you to categorize messages by severity.

Key log levels:

DEBUG: Detailed info, typically only for development.
INFO: Confirmation that things are working as expected.
WARNING: Something unexpected happened, but the software is still working.
ERROR: Serious problem, the software couldn't perform a function.
CRITICAL: A severe error, the program might be unable to continue.

Basic Logging in Action

With logging, you can control which messages are displayed based on their level. You can also direct logs to files, the network, or other destinations, making it much more flexible than print().

Run this example to see different log levels in action:

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.")

Integrating Logging with FastAPI

FastAPI applications, powered by Uvicorn, already use Python's logging module. When you add your own logging, you can often see it alongside Uvicorn's output.

You can create a named logger for your application to better organize your messages and control their output separately.

Here's a simple FastAPI example with integrated logging:

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")

Python's `breakpoint()` Function

Since Python 3.7, you can use the built-in breakpoint() function to pause your program's execution at a specific line.

When breakpoint() is called, Python will drop you into a debugger (often pdb, the Python Debugger). From there, you can inspect variables, step through code, and more.

This is extremely powerful for interactive debugging without needing a full IDE setup.

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}")

Power of IDE Debuggers

Integrated Development Environment (IDE) debuggers (like those in VS Code, PyCharm, or others) are the most powerful debugging tools. They offer a visual interface to control your program's execution.

Key benefits:

Visual Breakpoints: Click to set/clear.
Step-by-Step Execution: Control flow precisely.
Variable Inspection: See all variable values in real-time.
Call Stack: Understand how you got to the current point.

Setting & Using Breakpoints

A breakpoint is a marker you place in your code that tells the debugger to pause execution when that line is reached. This lets you 'freeze' your program at a specific moment.

In most IDEs, you set a breakpoint by simply clicking in the gutter (the area to the left of the line numbers) next to the line of code you want to pause at. When you run your application in debug mode, it will stop there.

Navigating Code: Step Over, Into, Out

Once execution is paused at a breakpoint, IDE debuggers provide controls to navigate your code:

Step Over: Executes the current line of code and moves to the next line. If the current line calls a function, the debugger executes the entire function without stepping into it.
Step Into: If the current line contains a function call, the debugger will jump inside that function, allowing you to debug its internal logic.
Step Out: Executes the remainder of the current function and returns to the line where the function was called.

Debugging Knowledge Check

Let's test your understanding of debugging techniques.

Debugging Essentials Recap

Great job! You've explored key debugging techniques for your FastAPI applications and Python code.

print(): Quick & dirty for immediate checks.
logging module: Structured, flexible, and scalable for production and development.
breakpoint(): Python's built-in way to pause execution and enter a debugger.
IDE Debuggers: The most powerful tools for visual step-by-step execution and state inspection.

Mastering these will significantly speed up your development and problem-solving process. Keep practicing them!

الأسئلة الشائعة

هل درس «تصحيح أخطاء تطبيقات FastAPI» مجاني؟

نعم — نص درس «تصحيح أخطاء تطبيقات FastAPI» كامل متاح مجاناً هنا على الويب. لتمرينه بشكل تفاعلي (محرر أكواد مدمج ومدرس ذكاء اصطناعي متاح 24/7) وفتح باقي دورة FastAPI Backend Development Bootcamp، انتقل إلى CoddyKit PRO. تتضمن دورة FastAPI Backend Development Bootcamp 4 دروس في المجموع.

ماذا ستتعلم في «تصحيح أخطاء تطبيقات FastAPI»؟

أتقنوا تقنيات تصحيح أخطاء FastAPI، بما في ذلك استخدام أدوات التصحيح في بيئات التطوير المتكاملة وتسجيل الأحداث. تتمرن على FastAPI Backend Development Bootcamp مع أكواد عملية تشغلها مباشرة في المتصفح، ومدرس ذكاء اصطناعي متاح 24/7 يجيب على أسئلتك أثناء عملك.

هل أحتاج إلى خبرة سابقة لأبدأ FastAPI Backend Development Bootcamp؟

لا تُشترط خبرة سابقة. FastAPI Backend Development Bootcamp على CoddyKit منظم للمبتدئين حتى المتقدمين، لذا يمكنك البدء من هنا أو من البداية والتقدم بسرعتك الخاصة. هذا هو الدرس 3 من أصل 4.

كم من الوقت يستغرق درس «تصحيح أخطاء تطبيقات FastAPI»؟

معظم دروس CoddyKit تستغرق حوالي 5–10 دقائق. كل منها موجز وتفاعلي، لذا تحرز تقدماً مستمراً وتستأنف من حيث توقفت عبر الويب والتطبيق.

هل يمكنني كتابة وتشغيل أكواد في درس FastAPI Backend Development Bootcamp هذا؟

نعم. كل درس في FastAPI Backend Development Bootcamp يتضمن محرر أكواد مدمج، لذا تكتب وتشغل أكواداً حقيقية مباشرة في متصفحك وتحصل على تعليقات فورية من الذكاء الاصطناعي — بدون إعداد محلي.

جميع الدروس في هذه الدورة

← العودة إلى FastAPI Backend Development Bootcamp