FastAPI Backend Development Bootcamp · บทเรียน

โมเดลการตอบกลับและรหัสสถานะ

เรียนรู้การกำหนดโมเดลการตอบกลับอย่างชัดเจน และตั้งรหัสสถานะ HTTP ที่เหมาะสมสำหรับการทำงานของ API รูปแบบต่าง ๆ

โมเดลการตอบกลับและรหัสสถานะ เป็นบทเรียน FastAPI Backend Development Bootcamp ฟรีบน CoddyKit นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน คุณสามารถอ่านบทเรียนทั้งหมดด้านล่างฟรี — จากนั้นลองปฏิบัติด้วยตัวคุณเองในเบราว์เซอร์พร้อมตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7 บทเรียนนี้เป็นส่วนหนึ่งของเส้นทางการเรียน FastAPI Backend Development Bootcamp และความก้าวหน้าของคุณจะซิงค์ข้ามเว็บและแอป CoddyKit คอร์ส FastAPI Backend Development Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน

บางส่วนของบทเรียนนี้ยังไม่ได้รับการแปล และแสดงเป็นภาษาอังกฤษ

API Responses: The Basics

When you make a request to an API, the server sends back a response. This response isn't just data; it also includes important information about the request's outcome.

FastAPI makes it easy to return data, usually as JSON. But we can make our APIs even better by being explicit about what data to expect and what happened.

Why Use Response Models?

Response models define the exact structure of the data your API will send back. This is crucial for several reasons:

Data Consistency: Ensures your API always returns data in a predictable format.
Automatic Docs: FastAPI automatically generates OpenAPI documentation showing the expected response structure.
Data Validation: FastAPI can validate the outgoing data against your model, catching errors before sending.

Defining a Simple Response Model

We use Pydantic models to define response structures. Then, we tell FastAPI which model to use with the response_model parameter in our endpoint decorator.

Try running this example and check the /docs endpoint!

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Product(BaseModel):
    name: str
    price: float
    is_available: bool = True

@app.get("/products/single", response_model=Product)
def get_single_product():
    return {"name": "Coffee Mug", "price": 9.99, "is_available": True}

# To run: uvicorn main:app --reload

Returning Lists with Response Models

What if your endpoint returns a list of items? You can specify this in your response_model by using Python's List type from the typing module.

This tells FastAPI to expect a list where each item matches your Pydantic model.

from fastapi import FastAPI
from pydantic import BaseModel
from typing import List

app = FastAPI()

class Book(BaseModel):
    title: str
    author: str

@app.get("/books", response_model=List[Book])
def get_all_books():
    return [
        {"title": "The Hobbit", "author": "J.R.R. Tolkien"},
        {"title": "1984", "author": "George Orwell"}
    ]

# To run: uvicorn main:app --reload

Understanding HTTP Status Codes

Beyond the data, every API response includes an HTTP Status Code. This three-digit number tells the client about the outcome of their request.

2xx Success: Request was successfully received, understood, and accepted. (e.g., 200 OK, 201 Created)
4xx Client Error: The client made an error. (e.g., 400 Bad Request, 404 Not Found)
5xx Server Error: The server failed to fulfill an apparently valid request. (e.g., 500 Internal Server Error)

FastAPI's Default Status Codes

FastAPI automatically assigns default status codes based on the HTTP method:

GET: 200 OK
POST: 200 OK (but often 201 Created is better)
PUT/DELETE: 200 OK

While these defaults work, explicitly setting status codes makes your API more precise and user-friendly.

Setting Custom Success Codes (201)

For operations that create a new resource (like a POST request), returning a 201 Created status code is best practice. You can specify this directly in your path operation decorator.

Run this and observe the network response code!

from fastapi import FastAPI, status
from pydantic import BaseModel

app = FastAPI()

class NewItem(BaseModel):
    name: str
    description: str | None = None

@app.post("/items", status_code=status.HTTP_201_CREATED)
def create_item(item: NewItem):
    # Imagine saving 'item' to a database here
    return {"message": "Item created successfully", "item": item}

# To run: uvicorn main:app --reload

Handling Errors with HTTPException (404)

When a requested resource isn't found, you should return a 404 Not Found status. FastAPI provides HTTPException to raise these errors easily.

This stops execution and returns a standard JSON error response.

from fastapi import FastAPI, HTTPException, status

app = FastAPI()

fake_items_db = {"foo": {"name": "Foo"}, "bar": {"name": "Bar"}}

@app.get("/items/{item_id}")
def read_item(item_id: str):
    if item_id not in fake_items_db:
        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Item not found")
    return fake_items_db[item_id]

# To run: uvicorn main:app --reload

Combining Models & Status Codes

You'll often use both response models and custom status codes together. For example, a successful update might return a 200 OK with the updated resource, while a failed update might return a 400 Bad Request.

This creates robust and predictable API behavior.

from fastapi import FastAPI, status
from pydantic import BaseModel

app = FastAPI()

class UserOut(BaseModel):
    id: int
    username: str

@app.put("/users/{user_id}", response_model=UserOut, status_code=status.HTTP_200_OK)
def update_user(user_id: int, new_username: str):
    # Imagine updating user in DB
    if user_id == 1:
        return {"id": user_id, "username": new_username}
    return {"id": user_id, "username": "default_user"}

# To run: uvicorn main:app --reload

Quick Check: Status Codes

A client sends a POST request to create a new user. The server successfully processes the request and saves the user data. Which HTTP status code is the most appropriate to return?

Recap: Clear Responses

In this lesson, you learned how to make your FastAPI responses clear and predictable. We covered:

Defining response models with Pydantic for consistent data and automatic documentation.
Understanding and explicitly setting HTTP status codes like 201 Created or handling errors with HTTPException for 404 Not Found.

These practices greatly improve the usability and robustness of your API.

คำถามที่พบบ่อย

บทเรียน “โมเดลการตอบกลับและรหัสสถานะ” ฟรีหรือไม่

ใช่ — ข้อความเต็มของ “โมเดลการตอบกลับและรหัสสถานะ” ฟรีให้อ่านที่นี่บนเว็บ เพื่อปฏิบัติแบบโต้ตอบ (ตัวแก้ไขโค้ดในตัวและติวเตอร์ AI ตลอด 24/7) และปลดล็อคส่วนที่เหลือของคอร์ส FastAPI Backend Development Bootcamp ให้อัปเกรดเป็น CoddyKit PRO คอร์ส FastAPI Backend Development Bootcamp มีบทเรียนทั้งหมด 4 บทเรียน

คุณจะเรียนรู้อะไรในบทเรียน “โมเดลการตอบกลับและรหัสสถานะ”

เรียนรู้การกำหนดโมเดลการตอบกลับอย่างชัดเจน และตั้งรหัสสถานะ HTTP ที่เหมาะสมสำหรับการทำงานของ API รูปแบบต่าง ๆ คุณปฏิบัติ FastAPI Backend Development Bootcamp ด้วยโค้ดที่ใช้งานได้จริงที่คุณเรียกใช้โดยตรงในเบราว์เซอร์ และติวเตอร์ AI ตลอด 24/7 ตอบคำถามของคุณขณะที่คุณไปผ่านบทเรียน

คุณต้องมีประสบการณ์ก่อนที่จะเริ่มเรียน FastAPI Backend Development Bootcamp หรือไม่

ไม่จำเป็นต้องมีประสบการณ์มาก่อน FastAPI Backend Development Bootcamp บน CoddyKit ออกแบบมาสำหรับผู้เริ่มต้นไปจนถึงผู้เรียนขั้นสูง คุณสามารถเริ่มต้นที่นี่หรือเริ่มจากตัวแรกและเรียนด้วยความเร็วของคุณเอง นี่คือบทเรียนที่ 2 จากทั้งหมด 4 บทเรียน

บทเรียน “โมเดลการตอบกลับและรหัสสถานะ” ใช้เวลานานแค่ไหน

บทเรียน CoddyKit ส่วนใหญ่ใช้เวลาประมาณ 5–10 นาที แต่ละบทเรียนจึงสั้นและเป็นแบบโต้ตอบ คุณสามารถก้าวหน้าอย่างต่อเนื่องและกลับมาเรียนต่อจากตรงที่เพิ่งหยุดบนเว็บและแอปได้เลย

ฉันเขียนและรันโค้ดในบทเรียน FastAPI Backend Development Bootcamp นี้ได้ไหม

ได้ บทเรียน FastAPI Backend Development Bootcamp ทุกบทมีตัวแก้ไขโค้ดในตัว คุณจึงเขียนและรันโค้ดจริงได้เลยในเบราว์เซอร์ และได้รับข้อเสนอแนะจาก AI ในทันที — ไม่ต้องติดตั้งในเครื่องของคุณ

บทเรียนทั้งหมดในหลักสูตรนี้

← กลับไปที่ FastAPI Backend Development Bootcamp