We’ll start by learning FastAPI’s key features and core use cases. Then we will run our first application and test it out! Finally, we will learn the details of supporting GET and POST operations that include request parameters and build and test those endpoints.

Why FastAPI?

First application

FastAPI vs. Django

GET operations

Hello world

Hello who?

POST operations

Pydantic model

POST operation in action

FastAPI Basics

We’ll start by learning how to support PUT and DELETE operations using FastAPI. Then we will learn how to handle different kinds of errors and always return an appropriate status code in the response. Lastly we'll learn how to use async to enable concurrent requests that can handle higher workloads.

Operasi PUT dan DELETE

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    ____: str
    ____: str

# Define items at application start
items = {"bananas": "Yellow fruit."}

app = FastAPI()


@app.put("/items")
def update_item(item: Item):
    name = item.name
    # Update the description
    items[____] = item.____
    return item

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str
    description: str

# Define items at application startup
items = {"bananas": "Yellow fruit."}

app = FastAPI()


@app.put("/items")
def update_item(item: Item):
    name = item.name
    # Update the description
    items[name] = item.description
    return item

Operasi PUT dalam praktik

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    ____: str

# Define items at application start
items = {"apples", "oranges", "bananas"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    # Delete the item
    items.remove(____)
    return {}

from fastapi import FastAPI
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

# Define items at application startup
items = {"apples", "oranges", "bananas"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    # Delete the item
    items.remove(name)
    return {}

Operasi DELETE secara langsung

Menangani galat

Opsi

Berhasil

Tidak berhasil

Klasifikasi status code

from fastapi import FastAPI, ____
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

# Define items at application startup
items = {"apples", "oranges"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    if name in items:
        items.remove(name)
    else:
        # Raise HTTPException with status code for "not found"
        raise ____(status_code=____, detail="Item not found.")
    return {}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

# Define items at application startup
items = {"apples", "oranges"}

app = FastAPI()


@app.delete("/items")
def delete_item(item: Item):
    name = item.name
    if name in items:
        items.remove(name)
    else:
        # Raise HTTPException with status code for "not found"
        raise HTTPException(status_code=404, detail="Item not found.")
    return {}

Menangani galat dari klien

Menggunakan async untuk pekerjaan konkuren

Kapan kita harus menggunakan async?

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

app = FastAPI()

items = {"rock", "paper", "scissors"}


@app.delete("/items")
# Make asynchronous
____ def root(item: Item):
    name = item.name
    # Check if name is in items
    if ____ not in ____:
        # Return the status code for not found
        raise HTTPException(status_code=___, detail="Item not found.")
    items.remove(name)
    return {"message": "Item deleted"}

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

# Define model Item
class Item(BaseModel):
    name: str

app = FastAPI()

items = {"rock", "paper", "scissors"}


@app.delete("/items")
# Make asynchronous
async def root(item: Item):
    name = item.name
    # Check if name is in items
    if name not in items:
        # Return the status code for not found
        raise HTTPException(status_code=404, detail="Item not found.")
    items.remove(name)
    return {"message": "Item deleted"}

Operasi DELETE Asinkron

FastAPI Advanced topics

We'll start by learning how to write system tests to validate individual FastAPI endpoints. Next we'll build a full JSON CRUD API to manage object lifecycles over HTTP. Finally, we'll learn how to test different application endpoints working together with manual functional tests.

FastAPI automated testing

Unit tests vs. system tests

System test

Building a JSON CRUD API

HTTP operations & CRUD steps

DELETE operation response

Complete JSON CRUD API

Writing a manual functional test

System tests vs. functional tests

Functional test

Wrap up

Building and testing a JSON CRUD API

Kursus ini mengajarkan Anda membangun aplikasi web tingkat produksi menggunakan FastAPI, kerangka kerja Python populer untuk membuat API. Anda akan mempelajari cara menangani keempat operasi HTTP, mendefinisikan skema permintaan dan respons, memvalidasi permintaan API, serta mengembalikan kode status HTTP yang sesuai. Anda juga akan mempelajari eksekusi kode asinkron untuk meningkatkan kinerja, dan pada akhirnya Anda akan mengembangkan API CRUD serta menguji alur kerja dengan modul requests di Python. Dirancang untuk pemrogram Python berpengalaman, kursus ini membekali Anda dengan keterampilan mengelola data dengan FastAPI, mempersiapkan Anda membangun pipeline manajemen data dan penyajian model ML yang tangguh.

<h2>Pengantar FastAPI dan Aplikasinya</h2> API sering digunakan untuk mengelola data di web, dan FastAPI adalah kerangka kerja web populer baru untuk membangun API dengan Python. Insinyur Data dan Machine Learning memanfaatkan FastAPI untuk membangun aplikasi yang berfungsi sebagai transaksi dan pipa data yang sadar konteks di web.<br><br> <h2>Membuat Aplikasi Web Berkelas Produksi dengan FastAPI</h2> Dalam kursus ini, Anda akan belajar cara membangun aplikasi web berkualitas produksi dengan memanfaatkan keterampilan Python Anda menggunakan kerangka kerja FastAPI. Pada akhirnya, Anda akan memahami penggunaan utama FastAPI dibandingkan dengan kerangka kerja web Python lainnya. Anda akan belajar cara membangun API menggunakan keempat jenis operasi HTTP dan mendefinisikan skema permintaan dan respons. Selain itu, Anda akan memvalidasi permintaan API, merespons dengan kode status HTTP yang sesuai dan pesan, serta menjalankan kode secara asinkron untuk meningkatkan kinerja aplikasi. Proyek praktis ini akan membimbing Anda dalam membangun API CRUD (Create, Read, Update, Delete) klasik, serta menguji alur kerja menggunakan modul requests Python.<br><br> <h2>Tujuan Kursus dan Sasaran Peserta</h2> Kursus ini dirancang untuk programmer Python berpengalaman yang ingin membangun aplikasi web yang mengelola data menggunakan FastAPI. Setelah menyelesaikan kursus ini, Anda akan memiliki dasar yang diperlukan untuk membuat proyek FastAPI yang cocok untuk pengelolaan data berkapasitas tinggi dan pipeline penyajian model ML.

Introduction to APIs in Python

Introduction to Object-Oriented Programming in Python

Bangun API andal dengan FastAPI, kuasai operasi HTTP, validasi, dan eksekusi async untuk pipeline data.

Pengantar FastAPI

Bangun API yang andal dan siap produksi dengan FastAPI, kuasai operasi HTTP, validasi, dan eksekusi asinkron untuk menciptakan alur data dan ML yang efisien.


Klasifikasi status code

Pengantar FastAPI

Latihan interaktif praktis